Update clock to be 70% max versus 80% to avoid unintended overlaps (#10516)

.claude/commands/README.md

@@ -0,0 +1,49 @@
+# Claude Code slash commands for the mcp-server test suite
+
+Three AI-assisted workflows wrapping `mcp-server/run-tests.sh` and the meshtastic MCP tools. Each one has a twin in `.github/prompts/` for Copilot users.
+
+| Slash command         | What it does                                                              | Copilot equivalent                       |
+| --------------------- | ------------------------------------------------------------------------- | ---------------------------------------- |
+| `/test [args]`        | Runs the test suite (auto-detects hardware) and interprets failures       | `.github/prompts/mcp-test.prompt.md`     |
+| `/diagnose [role]`    | Read-only device health report via the meshtastic MCP tools               | `.github/prompts/mcp-diagnose.prompt.md` |
+| `/repro <test> [n=5]` | Re-runs one test N times, diffs firmware logs between passes and failures | `.github/prompts/mcp-repro.prompt.md`    |
+
+## Why two surfaces
+
+The Claude Code commands and Copilot prompts cover the same three workflows but each speaks its host's idiom:
+
+- **Claude Code** (`/test`) uses `$ARGUMENTS` for pass-through, has direct access to Bash + all MCP tools registered in the user's settings, and runs in the terminal context.
+- **Copilot** (`/mcp-test`) runs in VS Code's agent mode; it has terminal + MCP access too but typically asks the operator to confirm inputs interactively.
+
+A contributor using either IDE gets equivalent assistance. Keep the two in sync when behavior changes — the diff of intent should be minimal.
+
+## House rules
+
+- **No destructive writes without explicit operator approval.** Skills that could reflash, factory-reset, or reboot a device must describe the action and stop — the operator authorizes.
+- **Interpret failures, don't just echo them.** The skill body should pull firmware log lines from `mcp-server/tests/report.html` (the `Meshtastic debug` section, attached by `tests/conftest.py::pytest_runtest_makereport`) and classify the failure.
+- **Keep MCP tool calls sequential per port.** SerialInterface holds an exclusive port lock; two parallel tool calls on the same port deadlock.
+- **Never speculate about root cause.** If the evidence doesn't support a classification, say "unknown" and list what you'd need to disambiguate.
+
+## Adding a new command
+
+1. Write the Claude Code version at `.claude/commands/<name>.md` with YAML frontmatter:
+
+   ```yaml
+   ---
+   description: one-line purpose (used for auto-invocation by the model)
+   argument-hint: [optional-hint]
+   ---
+   ```
+
+2. Write the Copilot equivalent at `.github/prompts/mcp-<name>.prompt.md` with:
+
+   ```yaml
+   ---
+   mode: agent
+   description: ...
+   ---
+   ```
+
+3. Add the row to the table above. Cross-link in both bodies.
+
+4. Smoke-test on Claude Code first (`/<name>` should appear in autocomplete), then in VS Code Copilot (`/mcp-<name>` in Chat).

.claude/commands/diagnose.md

@@ -0,0 +1,68 @@
+---
+description: Produce a device health report using the meshtastic MCP tools (device_info, list_nodes, get_config, short serial log capture)
+argument-hint: [role=all|nrf52|esp32s3|<port>]
+---
+
+# `/diagnose` — device health report
+
+Call the meshtastic MCP tool bundle and format a structured health report for one or all detected devices. Zero guesswork for the operator.
+
+## What to do
+
+1. **Enumerate hardware.** Call `mcp__meshtastic__list_devices(include_unknown=True)`. For each entry where `likely_meshtastic=True`, capture `port`, `vid`, `pid`, `description`.
+
+2. **Filter by `$ARGUMENTS`**:
+   - No args, `all` → every likely-meshtastic device.
+   - `nrf52` → only devices with `vid == 0x239a`.
+   - `esp32s3` → only devices with `vid == 0x303a` or `vid == 0x10c4`.
+   - A `/dev/cu.*` path → only that one port.
+   - Anything else → treat as a substring match against the `port` string.
+
+3. **For each selected device, in sequence (NOT parallel — SerialInterface holds an exclusive port lock):**
+   - `mcp__meshtastic__device_info(port=<p>)` — captures `my_node_num`, `long_name`, `short_name`, `firmware_version`, `hw_model`, `region`, `num_nodes`, `primary_channel`.
+   - `mcp__meshtastic__list_nodes(port=<p>)` — count of peers, which ones have `publicKey` set, SNR/RSSI distribution.
+   - `mcp__meshtastic__get_config(section="lora", port=<p>)` — region, preset, channel_num, tx_power, hop_limit.
+   - Optionally, if the device seems unhappy (fails to connect, `num_nodes==1` when ≥2 are plugged in, missing firmware*version), open a short firmware log window: `mcp__meshtastic__serial_open(port=<p>, env=<inferred-env>)`, wait 3s, `serial_read(session_id=<s>, max_lines=100)`, `serial_close(session_id=<s>)`. The env should be inferred from the VID map in `mcp-server/run-tests.sh` (nrf52 → rak4631, esp32s3 → heltec-v3) unless `MESHTASTIC_MCP_ENV*<ROLE>` is set.
+
+4. **Hub health** (call once, not per-device): `mcp__meshtastic__uhubctl_list()` — enumerates every USB hub the host can see. Note which hubs advertise `ppps=true` and which hub hosts each Meshtastic device (cross-reference by VID). Flag it in the report if:
+   - No hub advertises PPPS → `tests/recovery/` can't run on this setup; hard-recovery via `uhubctl_cycle` isn't available.
+   - A Meshtastic device is on a non-PPPS hub → note it; operator may want to move the device to a PPPS hub to unlock auto-recovery.
+   - `uhubctl_list` raises `ConfigError: uhubctl not found` → just say `uhubctl not installed` in the report; don't treat as a fault.
+
+5. **Render per-device report** as:
+
+   ```text
+   [nrf52 @ /dev/cu.usbmodem1101]      fw=2.7.23.bce2825, hw=RAK4631
+     owner       : Meshtastic 40eb / 40eb
+     region/band : US, channel 88, LONG_FAST
+     tx_power    : 30 dBm, hop_limit=3
+     peers       : 1 (esp32s3 0x433c2428, pubkey ✓, SNR 6.0 / RSSI -24 dBm)
+     primary ch  : McpTest
+     hub         : 1-1.3 port 2 (PPPS, uhubctl-controllable)
+     firmware    : no panics in last 3s; NodeInfoModule emitted 2 broadcasts
+   ```
+
+   Keep it scannable. If a field is missing or abnormal (no pubkey for a known peer, region=UNSET, num_nodes inconsistent with the hub, device on non-PPPS hub), flag it inline with a short `⚠︎ <one-line reason>`.
+
+6. **Cross-device correlation** (only when >1 device is inspected):
+   - Do both sides see each other in `nodesByNum`? If one does and the other doesn't, that's asymmetric NodeInfo — flag it.
+   - Do the LoRa configs match? (region, channel_num, modem_preset should all agree; mismatch = no mesh)
+   - Do the primary channel NAMES match? Mismatch = different PSK = no decode.
+
+7. **Recorder slice (cheap, always available).** The mcp-server runs an autouse log recorder that's been collecting from every connected device. Pull two short slices to surface anything weird that's already happened:
+   - `mcp__meshtastic__logs_window(start="-2m", level="WARN|ERROR|CRIT", max_lines=20)` — recent firmware errors. If empty, say "no recent errors"; don't manufacture concern.
+   - `mcp__meshtastic__telemetry_timeline(window="1h", field="free_heap", max_points=60)` — heap trend. If `slope_per_min < -50`, flag it and recommend `/leakhunt window=6h` for a deeper read; otherwise just note the current free heap.
+   - If `recorder_status` shows `running:false` or `files.telemetry.last_ts` is null, note "recorder has no telemetry yet — enable `set_debug_log_api(True)` to populate" and skip this step gracefully.
+
+8. **Suggest next actions only for specific, recognisable failure modes**:
+   - Stale PKI pubkey one-way → "run `/test tests/mesh/test_direct_with_ack.py` — the retry + nodeinfo-ping heals this in the test path."
+   - Region mismatch → "re-bake one side via `./mcp-server/run-tests.sh --force-bake`."
+   - Device unreachable, reachable via DFU → `touch_1200bps(port=...)` + `pio_flash`. If not even DFU responds AND the device is on a PPPS hub, escalate to `uhubctl_cycle(role=..., confirm=True)`.
+   - CP2102-wedged-driver on macOS → see the note in `run-tests.sh`.
+   - Heap slope strongly negative → "run `/leakhunt window=6h` for a full timeline + classification."
+
+## What NOT to do
+
+- No writes. No `set_config`, no `reboot`, no `factory_reset`. This is a read-only diagnostic skill — if the operator wants to change state, they'll ask explicitly.
+- No `flash` / `erase_and_flash`. Those are separate escalations.
+- No holding SerialInterface across tool calls — open, query, close; next device. The port lock is exclusive.

.claude/commands/leakhunt.md

@@ -0,0 +1,103 @@
+---
+description: Hunt for memory leaks (and other slow degradations) by reading the persistent recorder's heap timeline + log slice over a window
+argument-hint: [window=1h] [field=free_heap] [variant=local]
+---
+
+<!-- markdownlint-disable MD029 -->
+
+# `/leakhunt` — read the recorder, classify a memory leak
+
+Use the always-on recorder (`mcp-server/.mtlog/`) to read a heap timeline plus the matching log slice and produce a one-page verdict: **steady / slow leak / fragmentation / OOM-imminent**. No firmware changes, no special build flags — the LocalStats telemetry packet that the firmware already broadcasts every ~60 s carries `heap_free_bytes` and `heap_total_bytes`.
+
+## Two signal paths — pick the right one
+
+| Path                  | Build flag       | Cadence        | Per-thread attribution | Cost                      |
+| --------------------- | ---------------- | -------------- | ---------------------- | ------------------------- |
+| LocalStats packet     | (default)        | ~60 s          | No                     | Free — always on          |
+| `[heap N]` log prefix | `-DDEBUG_HEAP=1` | every log line | Yes (Thread X leaked)  | Bigger flash + log volume |
+
+Both feed the same `telemetry_timeline(field="free_heap")` query — when DEBUG_HEAP is on, the recorder synthesizes telemetry rows from log prefixes (tagged `source: debug_heap`), so a single timeline call gets whichever signal is available. **For a slow leak diagnosis, the default path is plenty** (60 s cadence over 6 h = 360 points; linear regression over that nails sub-100-byte/min slopes). **DEBUG_HEAP is for attribution** — when the slope is real and you need to know which thread is leaking.
+
+## What to do
+
+1. **Parse `$ARGUMENTS`**: optional `window` (default `1h`, accepts `30m`/`6h`/`-3d`/etc.), optional `field` (default `free_heap`; alternates: `total_heap`, `battery_level`, anything in the LocalStats variant), optional `variant` (default `local`; alternates: `device`, `environment`, `power`, `airQuality`, `health`).
+
+2. **Verify the recorder is alive** — call `mcp__meshtastic__recorder_status`. Check:
+   - `running == True`
+   - `files.telemetry.lines > 0` (at least one telemetry packet recorded — if zero, the device hasn't broadcast LocalStats yet OR `set_debug_log_api` has never been on; tell the operator to run `mcp__meshtastic__set_debug_log_api(enabled=True)` and wait one device-update interval)
+   - `files.telemetry.last_ts` within the last 5 minutes (if older, the device is silent — log that, not "leak detected")
+
+3. **Detect whether DEBUG_HEAP is active** — `mcp__meshtastic__logs_window(start="-2m", grep=r"\\[heap \\d+\\]", max_lines=3)`. If any line matches, the firmware has the prefix → DEBUG_HEAP is on, expect higher-cadence data and `heap_event` rows. If zero matches over the last 2 minutes, you're on the LocalStats-only path.
+
+4. **Pull the timeline** — `mcp__meshtastic__telemetry_timeline(window=$window, variant=$variant, field=$field, max_points=200)`. Read:
+   - `samples` — how many raw points contributed
+   - `min`, `max` — total swing
+   - `slope_per_min` — units per minute (linear regression over the whole window)
+
+5. **Pull the log context for the same window** — `mcp__meshtastic__logs_window(start="-${window}", grep="Heap status|leaked heap|freed heap|out of memory|Alloc an err|panic|abort", max_lines=200)`. These are the strings the firmware emits when something memory-related happens (`DEBUG_HEAP` builds emit `"Heap status:"` and `"leaked heap"` lines; production builds emit `"Alloc an err"` on failure and `"out of memory"` on OOM).
+
+6. **Pull marker events** so we know if the operator labeled phases — `mcp__meshtastic__events_window(start="-${window}", kind="mark|connection_lost|connection_established")`. If a `connection_lost` overlaps a sharp drop, that's not a leak; that's a reboot.
+
+6a. **(DEBUG_HEAP only) Per-thread attribution** — `mcp__meshtastic__logs_window(start="-${window}", grep="leaked heap", max_lines=200)`. Each row has a structured `heap_event` field with `{kind, thread, before, after, delta}`. Aggregate by thread: sum the `delta` over the window per thread name. The thread with the largest cumulative negative delta is your suspect. Note the count too — a thread with 50× small leaks is different from 1× big leak.
+
+7. **Classify** based on what the data says, NOT on what you wish it said. Use these rules in order:
+   - **Insufficient data** (< 5 samples): say so. Suggest a longer window or longer wait. Stop.
+   - **Reboot mid-window**: if any `connection_lost` event is present AND `free_heap` jumped UP at that timestamp, the device rebooted. Note it; pre-reboot trend may be a leak but you only have part of the curve.
+   - **OOM-imminent**: any `Alloc an err=` or `out of memory` line in the log slice. This trumps everything; flag urgently.
+   - **Slow leak**: `slope_per_min < -50` AND `max - min > 1000` AND no reboot. The heap is monotonically (or near-monotonically) declining. Estimate time-to-zero: `min / -slope_per_min` minutes. Surface it.
+   - **Fragmentation suspect**: `slope_per_min` close to zero (|x| < 50) BUT min trends down across the window AND the log slice shows `Alloc an err` warnings WITHOUT total OOM. Means free total is OK but largest contiguous block is shrinking. Recommend a `DEBUG_HEAP` build to confirm.
+   - **Steady**: |slope_per_min| < 50, no error lines. Heap is fine.
+   - **Recovery curve**: slope is POSITIVE — heap recovered. Either a workload completed or GC fired. Note it; not a leak.
+
+8. **Report**:
+
+   ```text
+   /leakhunt window=6h field=free_heap variant=local
+   ────────────────────────────────────────────────────
+   recorder        : running, telem last_ts 8s ago
+   build           : DEBUG_HEAP=ON (per-line prefix detected)
+   samples         : 14,200 over 6h (cadence ~1.5s, log-line synth)
+   free_heap       : min 92,344 / max 124,008 / range 31,664
+   slope           : -82 bytes/min (negative — heap declining)
+   reboots         : none in window
+   OOM events      : none
+   error lines     : 3× "Alloc an err=ESP_ERR_NO_MEM" at +4h12m, +5h08m, +5h44m
+   thread leaks    : (DEBUG_HEAP) MeshPacket -3,124 B over 18 events
+                                  Router       -1,408 B over 4 events
+                                  others       -240 B
+   verdict         : SLOW LEAK — primary suspect MeshPacket thread
+   est. time-to-OOM: ~1,127 min (~18.8 h) at current slope
+   evidence        : (3 log line citations with uptimes)
+   ```
+
+   Then: **what to do next.**
+   - SLOW LEAK, **DEBUG_HEAP off** → recommend rebuilding with the flag and re-running this skill. Concrete one-liner the operator can copy:
+     ```text
+     mcp__meshtastic__build(env="<env>", build_flags={"DEBUG_HEAP": 1})
+     mcp__meshtastic__pio_flash(env="<env>", port="<port>", confirm=True)
+     ```
+     After flash, set debug_log_api back on and wait one window; re-run `/leakhunt`.
+   - SLOW LEAK, **DEBUG_HEAP on** → cite the top-leaking thread name from step 6a. Point at the corresponding source file (`grep -rn "ThreadName(\"<name>\")" src/`); the operator decides what to fix.
+   - FRAGMENTATION SUSPECT → propose pre-allocating any per-packet buffers; or rebuilding with `CONFIG_HEAP_TASK_TRACKING=y` on ESP32 to see who's holding the largest blocks.
+   - OOM-IMMINENT → flag for immediate attention; don't wait for the next telemetry interval.
+   - STEADY → say so; stop. Don't invent problems.
+
+## What NOT to do
+
+- Don't assume a leak from a single dip. LocalStats fires every ~60 s and the firmware naturally allocates+frees on each broadcast cycle; one packet sees the trough. Look at the slope, not the deltas.
+- Don't recommend code changes. This skill diagnoses; the operator decides what to fix.
+- Don't enable `set_debug_log_api` automatically — if it's off, telemetry isn't reaching pubsub anyway, and the recorder will be empty. Tell the operator to flip it on and wait, then re-run.
+- Don't run heavy workloads to "trigger the leak." The recorder is passive; we read what's there.
+
+## Companion: `mark_event` for stress runs
+
+If the operator wants to test under stimulus (e.g. blast 50 broadcasts and see what the heap does), they can frame the experiment with markers:
+
+```text
+mark_event("burst-start")
+… run the workload …
+mark_event("burst-end")
+/leakhunt window=15m
+```
+
+The markers land in both `events.jsonl` and `logs.jsonl`, so the report can show "free_heap dipped 8 KB during the burst window, recovered to baseline within 2 LocalStats cycles" → not a leak.

.claude/commands/repro.md

@@ -0,0 +1,70 @@
+---
+description: Re-run a specific test N times in isolation to triage flakes, diff firmware logs between passes and failures
+argument-hint: <test-node-id> [count=5]
+---
+
+<!-- markdownlint-disable MD029 -->
+
+# `/repro` — flakiness triage for one test
+
+Re-run a single pytest node ID N times in isolation, track pass rate, and surface what's _different_ in the firmware logs between the passing attempts and the failing ones. Turns "it's flaky, I guess" into "it fails when X, passes when Y."
+
+## What to do
+
+1. **Parse `$ARGUMENTS`**: first token is the pytest node id (e.g. `tests/mesh/test_direct_with_ack.py::test_direct_with_ack_roundtrip[nrf52->esp32s3]`); second token is an integer count (default `5`, cap at `20`). If the first token doesn't look like a test path (no `::` and no `tests/` prefix), treat the whole `$ARGUMENTS` as a `-k` filter instead.
+
+2. **Sanity-check the hub first** (so we're not measuring "nothing plugged in" N times): call `mcp__meshtastic__list_devices`. If the test name contains `nrf52` or `esp32s3` and the matching VID isn't present, stop and report — re-running won't help.
+
+3. **Loop N times**. For each iteration:
+
+   ```bash
+   ./mcp-server/run-tests.sh <test-id> --tb=short -p no:cacheprovider
+   ```
+
+   Capture: exit code, duration, and (on failure) the `Meshtastic debug` firmware log section from `mcp-server/tests/report.html`. `-p no:cacheprovider` suppresses pytest's `.pytest_cache` writes so iterations don't influence each other.
+
+4. **Track a small structured tally**:
+
+   ```text
+   attempt 1: PASS (42s)
+   attempt 2: FAIL (128s)  ← firmware log 200-line tail captured
+   attempt 3: PASS (39s)
+   attempt 4: FAIL (121s)
+   attempt 5: PASS (41s)
+   --------------------------------------
+   pass rate: 3/5 (60%)   |   mean duration: 74s
+   ```
+
+5. **On mixed outcomes**: diff the firmware log tails between a representative passing attempt and a representative failing attempt. Focus on:
+   - Error-level lines only present in failures (`PKI_UNKNOWN_PUBKEY`, `Alloc an err=`, `Skip send`, `No suitable channel`)
+   - Timing around the assertion event — did a broadcast go out, was there an ACK, did NAK fire?
+   - Device state fields that changed (nodesByNum entries, region/preset, channel_num)
+
+   Surface the top 3 differences as a "passes when / fails when" table. Don't dump full logs — pull specific lines with uptime timestamps.
+
+5a. **Archive recorder slices per attempt** (no extra device interaction; the recorder runs autouse). Right after each attempt finishes, capture its `(start_ts, end_ts)` and call `mcp__meshtastic__recorder_export(start=<start>, end=<end>, dest_dir="mcp-server/tests/repro_artifacts/<safe-test-id>/attempt_<n>/")`. This drops a `logs.jsonl`, `telemetry.jsonl`, `packets.jsonl`, and `events.jsonl` snapshot scoped to the attempt window. Use these for cross-attempt diffs in step 5: `jq '.line' logs.jsonl` is faster than re-running the test, and the telemetry slice lets you compare heap behavior across attempts.
+
+6. **Classify the flake** into one of:
+   - **LoRa airtime collision** → pass rate improves with fewer concurrent transmitters; propose a `time.sleep` gap or retry bump in the test body.
+   - **PKI key staleness** → fails on first attempt, passes after self-heal; existing retry loop in `test_direct_with_ack.py` handles this.
+   - **NodeInfo cooldown** → `Skip send NodeInfo since we sent it <600s ago` in fail-only logs; needs `broadcast_nodeinfo_ping()` warmup.
+   - **Hardware-specific** (one direction fails, other passes; one device's firmware is older; driver wedged) → specific recovery pointer. For a device that's wedged past `touch_1200bps`, the next escalation is `uhubctl_cycle(role=..., confirm=True)` to hard-power-cycle its hub port (requires `uhubctl` installed).
+   - **Device went dark mid-run** → fails from some attempt onward, never recovers, firmware log stops arriving. Almost always hardware: a Guru crash + frozen CDC. Hard-power-cycle via `uhubctl_cycle(role=..., confirm=True)` before the next iteration; if that also fails, escalate to replug.
+   - **Genuinely unknown** → say so; don't invent a root cause.
+
+7. **Report back** with:
+   - Pass rate and mean duration.
+   - Classification + evidence (the specific log lines that support it).
+   - A suggested next step (re-run with specific args, open `/diagnose`, edit a specific test file, nothing).
+
+## Examples
+
+- `/repro tests/mesh/test_direct_with_ack.py::test_direct_with_ack_roundtrip[esp32s3->nrf52] 10` — runs 10 times, diffs firmware logs.
+- `/repro broadcast_delivers` — no `::`, no `tests/`, so interpreted as `-k broadcast_delivers`; runs every matching test the default 5 times.
+- `/repro tests/telemetry/test_device_telemetry_broadcast.py 3` — shorter run for a slow test.
+
+## Constraints
+
+- Don't exceed `count=20` per invocation — airtime and USB wear add up. If the user asks for 50, negotiate down.
+- Don't rebuild firmware as part of triage; flakes that only reproduce under different firmware belong in a separate session.
+- If the FIRST attempt fails AND the rest all pass, that's a classic "state leak from a prior test" → say so and suggest running with `--force-bake` or starting from a clean state rather than chasing the first failure.

.claude/commands/test.md

@@ -0,0 +1,47 @@
+---
+description: Run the mcp-server test suite (auto-detects devices) and interpret the results
+argument-hint: [pytest-args]
+---
+
+# `/test` — mcp-server test runner with interpretation
+
+Run `mcp-server/run-tests.sh` and make sense of the output so the operator doesn't have to.
+
+## What to do
+
+1. **Invoke the wrapper.** From the firmware repo root, run:
+
+   ```bash
+   ./mcp-server/run-tests.sh $ARGUMENTS
+   ```
+
+   The wrapper auto-detects connected Meshtastic devices, maps each to its PlatformIO env, exports the required `MESHTASTIC_MCP_ENV_*` env vars, and invokes pytest. If the user passed no arguments, the wrapper supplies a sensible default set (`tests/ --html=tests/report.html --self-contained-html --junitxml=tests/junit.xml -v --tb=short`). A `--report-log=tests/reportlog.jsonl` arg is always appended (unless the operator passed their own). `--assume-baked` is deliberately NOT in the defaults — `test_00_bake.py` has its own skip-if-already-baked check and runs the ~8 s verification by default. Operators can opt into the fast path with `--assume-baked`, or force a reflash with `--force-bake`.
+
+2. **Read the pre-flight header.** First ~6 lines print the detected hub (role → port → env). If that line reads `detected hub : (none)`, the wrapper will narrow to `tests/unit` only — say so explicitly in your summary so the operator knows hardware tiers were skipped.
+
+3. **On pass**: one-line summary of the form `N passed, M skipped in <duration>`. Don't enumerate the test names — the user can read those. Do mention any SKIPPED tests and name the cause:
+   - `"role not present on hub"` → device unplugged; operator knows to reconnect.
+   - `"firmware not baked with USERPREFS_UI_TEST_LOG"` → tests/ui skipped because the macro isn't in firmware yet; suggest `--force-bake`.
+   - `"uhubctl not installed"` → tests/recovery + peer-offline skipped; suggest `brew install uhubctl` / `apt install uhubctl`.
+   - `"no PPPS-capable hubs detected"` → tests/recovery skipped because the hub doesn't support per-port power; the tier will never run on that setup.
+   - `"opencv-python-headless is not installed"` → tests/ui auto-deselected by run-tests.sh; suggest `pip install -e 'mcp-server/.[ui]'`.
+
+4. **On failure**: for every FAILED test, open `mcp-server/tests/report.html` and extract the `Meshtastic debug` section for that test. pytest-html embeds the firmware log stream + device state dump there; the 200-line firmware log tail is usually enough to explain the failure. Summarise: which test, one-line assertion message, the firmware log lines that matter (things like `PKI_UNKNOWN_PUBKEY`, `Skip send NodeInfo`, `Error=`, `Guru Meditation`, `assertion failed`). For UI-tier failures also glance at `mcp-server/tests/ui_captures/<session>/<test>/transcript.md` — it records each step's frame + OCR.
+
+5. **Classify the failure** as one of:
+   - **Transient/flake**: LoRa collision, timing-sensitive assertion, first-attempt NAK + successful retry pattern. Propose `/repro <test_node_id>` to confirm.
+   - **Environmental**: device unreachable, port busy, CP2102 driver wedged. Suggest the specific recovery in escalation order: (a) replug USB, (b) `touch_1200bps(port=...)` + `pio_flash` for nRF52 DFU, (c) `uhubctl_cycle(role="nrf52", confirm=True)` when a device is fully wedged past DFU (needs `uhubctl` installed — `baked_single`'s auto-recovery hook does this once automatically). Also check `git status userPrefs.jsonc`.
+   - **Regression**: same assertion fails repeatedly, firmware log shows a new/unusual error. Surface the diff between expected and observed, identify the module likely responsible.
+
+6. **Never run destructive recovery automatically.** If a failure looks like it needs a reflash, factory*reset, `uhubctl_cycle`, or USB replug, \_describe what to do* — don't execute. The operator decides.
+
+## Arguments handling
+
+- No args → wrapper's defaults (full suite).
+- `$ARGUMENTS` passed verbatim to the wrapper, which passes them to pytest.
+- Common operator invocations: `/test tests/mesh`, `/test tests/mesh/test_direct_with_ack.py::test_direct_with_ack_roundtrip`, `/test --force-bake`, `/test -k telemetry`.
+
+## Side-effects to mention in summary
+
+- The session fixture snapshots `userPrefs.jsonc` at session start and restores at teardown (plus on `atexit`). After a clean run, `git status userPrefs.jsonc` should be empty. If the wrapper's pre-flight printed a warning about a stale sidecar, call that out — means a prior session crashed.
+- `mcp-server/tests/report.html` and `junit.xml` are regenerated on every run; the HTML is self-contained (shareable).

.claude/settings.json

@@ -1,17 +0,0 @@
-{
-  "hooks": {
-    "PostToolUse": [
-      {
-        "matcher": "Write|Edit",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "f=$(tr -d '\\n' | grep -o '\"file_path\"[[:space:]]*:[[:space:]]*\"[^\"]*\"' | head -1 | sed 's/.*:[[:space:]]*\"//; s/\"$//'); [ -n \"$f\" ] && [ -f \"$f\" ] || exit 0; t=$(command -v trunk || echo \"$HOME/.cache/trunk/launcher/trunk\"); [ -x \"$t\" ] || { echo \"trunk-fmt hook: trunk not found; its launcher needs curl or wget to bootstrap the CLI (see 'Formatting & the trunk toolchain' in .github/copilot-instructions.md)\" >&2; exit 1; }; out=$(\"$t\" fmt --force \"$f\" 2>&1) || { echo \"trunk-fmt hook: trunk fmt failed on $f: $out\" >&2; exit 1; }",
-            "timeout": 120,
-            "statusMessage": "Formatting (trunk)..."
-          }
-        ]
-      }
-    ]
-  }
-}

.clusterfuzzlite/Dockerfile

@@ -4,18 +4,21 @@
 # As this is not a long running service, health-checks are not required. ClusterFuzzLite
 # also only works if the user remains unchanged from the base image (it expects to run
 # as root).
-# trunk-ignore-all(trivy/DS-0026): No healthcheck is needed for this builder container
+# trunk-ignore-all(trivy/DS026): No healthcheck is needed for this builder container
 # trunk-ignore-all(checkov/CKV_DOCKER_2): No healthcheck is needed for this builder container
 # trunk-ignore-all(checkov/CKV_DOCKER_3): We must run as root for this container
-# trunk-ignore-all(trivy/DS-0002): We must run as root for this container
+# trunk-ignore-all(trivy/DS002): We must run as root for this container
+# trunk-ignore-all(checkov/CKV_DOCKER_8): We must run as root for this container
+# trunk-ignore-all(hadolint/DL3002): We must run as root for this container
 
 FROM gcr.io/oss-fuzz-base/base-builder:v1
 
 ENV PIP_ROOT_USER_ACTION=ignore
 
 # trunk-ignore(hadolint/DL3008): apt packages are not pinned.
+# trunk-ignore(terrascan/AC_DOCKER_0002): apt packages are not pinned.
 RUN apt-get update && apt-get install --no-install-recommends -y \
-        cmake git zip libgpiod-dev libjsoncpp-dev libbluetooth-dev libi2c-dev \
+        cmake git zip libgpiod-dev libbluetooth-dev libi2c-dev \
         libunistring-dev libmicrohttpd-dev libgnutls28-dev libgcrypt20-dev \
         libusb-1.0-0-dev libssl-dev pkg-config libsqlite3-dev libsdl2-dev && \
     apt-get clean && rm -rf /var/lib/apt/lists/* && \

.clusterfuzzlite/build.sh

@@ -31,7 +31,7 @@ cmake --install "$WORK/ulfius/$SANITIZER" --prefix /usr
 cd "$SRC/firmware"
 
 PLATFORMIO_EXTRA_SCRIPTS=$(echo -e "pre:.clusterfuzzlite/platformio-clusterfuzzlite-pre.py\npost:.clusterfuzzlite/platformio-clusterfuzzlite-post.py")
-STATIC_LIBS=$(pkg-config --libs --static libulfius openssl libgpiod yaml-cpp jsoncpp bluez --silence-errors)
+STATIC_LIBS=$(pkg-config --libs --static libulfius openssl libgpiod yaml-cpp bluez --silence-errors)
 export PLATFORMIO_EXTRA_SCRIPTS
 export STATIC_LIBS
 export PLATFORMIO_WORKSPACE_DIR="$WORK/pio/$SANITIZER"

.coderabbit.yaml

@@ -1,46 +0,0 @@
-# yaml-language-server: $schema=https://coderabbit.ai/integrations/schema.v2.json
-# CodeRabbit config - see https://docs.coderabbit.ai/getting-started/yaml-configuration
-language: en-US
-
-reviews:
-  # chill = fewer nitpicks.
-  profile: chill
-  high_level_summary: true
-  poem: false
-  auto_review:
-    enabled: true
-    # Don't burn reviews on WIP. This repo opens lots of draft PRs; review on "ready".
-    drafts: false
-    # Review PRs regardless of target branch.
-    base_branches:
-      - .*
-    # Skip Renovate dependency updates - CI gates dependencies; we review for substance, not every bump.
-    ignore_usernames:
-      - renovate
-      - renovate[bot]
-  # Stop reviewing once a PR is closed.
-  abort_on_close: true
-
-  path_filters:
-    # Generated - don't review, just noise + token burn.
-    - "!src/mesh/generated/**"
-    - "!protobufs/**"
-
-  path_instructions:
-    - path: bin/config.d/**
-      instructions: >
-        meshtasticd configuration files. Bundled with meshtasticd Linux/MacOS packaging.
-        Ensure configurations include metadata found in other configs.
-    - path: "**/*.md"
-      instructions: >
-        Documentation does not live in this repo; it lives in
-        https://github.com/meshtastic/meshtastic. Flag any NEW .md file that documents a
-        feature, configuration surface, API, wire format, or design, and ask for it to be
-        opened against the docs repo instead. Flag any attempt to recreate a docs/
-        directory: it was deleted in #11488 and must not come back. Flag write-ups left in
-        the tree - investigation notes, mitigation plans, migration checklists, "how we got
-        here" narrative, summaries of what a change did - that content belongs in the PR
-        description and commit message. Documentation that does belong upstream must read
-        as a technical manual, not a novel: what it does, the settings in user terms, the
-        API or protocol a client speaks. No debugging journey, no rationale essays, no
-        changelog prose.

.devcontainer/Dockerfile

@@ -1,3 +1,4 @@
+# trunk-ignore-all(terrascan/AC_DOCKER_0002): Known terrascan issue
 # trunk-ignore-all(hadolint/DL3008): Do not pin apt package versions
 # trunk-ignore-all(hadolint/DL3013): Do not pin pip package versions
 FROM mcr.microsoft.com/devcontainers/cpp:2-debian-13
@@ -15,7 +16,6 @@ RUN apt-get update && export DEBIAN_FRONTEND=noninteractive \
     libssl-dev \
     libulfius-dev \
     libyaml-cpp-dev \
-    libjsoncpp-dev \
     pipx \
     pkg-config \
     python3 \

.devcontainer/devcontainer.json

@@ -8,7 +8,7 @@
   "features": {
     "ghcr.io/devcontainers/features/python:1": {
       "installTools": true,
-      "version": "3.14"
+      "version": "3.13"
     }
   },
   "customizations": {

.github/actions/build-variant/action.yml

@@ -76,7 +76,7 @@ runs:
         done
 
     - name: PlatformIO ${{ inputs.arch }} download cache
-      uses: actions/cache@v6
+      uses: actions/cache@v5
       with:
         path: ~/.platformio/.cache
         key: pio-cache-${{ inputs.arch }}-${{ hashFiles('.github/actions/**', '**.ini') }}

.github/actions/setup-base/action.yml

@@ -5,7 +5,7 @@ runs:
   using: composite
   steps:
     - name: Checkout code
-      uses: actions/checkout@v7
+      uses: actions/checkout@v6
       with:
         submodules: recursive
 
@@ -13,7 +13,7 @@ runs:
       shell: bash
       run: |
         sudo apt-get -y update --fix-missing
-        sudo apt-get install -y cppcheck libbluetooth-dev libgpiod-dev libyaml-cpp-dev libjsoncpp-dev lsb-release
+        sudo apt-get install -y cppcheck libbluetooth-dev libgpiod-dev libyaml-cpp-dev lsb-release
 
     - name: Setup Python
       uses: actions/setup-python@v6

.github/actions/setup-native/action.yml

@@ -11,4 +11,4 @@ runs:
     - name: Install libs needed for native build
       shell: bash
       run: |
-        sudo apt-get install -y libbluetooth-dev libgpiod-dev libyaml-cpp-dev libjsoncpp-dev openssl libssl-dev libulfius-dev liborcania-dev libusb-1.0-0-dev libi2c-dev libuv1-dev libcurl4-gnutls-dev
+        sudo apt-get install -y libbluetooth-dev libgpiod-dev libyaml-cpp-dev openssl libssl-dev libulfius-dev liborcania-dev libusb-1.0-0-dev libi2c-dev libuv1-dev

.github/copilot-instructions.md

@@ -1,23 +1,5 @@
 # Meshtastic Firmware - Copilot Instructions
 
-> **TL;DR**
->
-> |                |                                                                                                                        |
-> | -------------- | ---------------------------------------------------------------------------------------------------------------------- |
-> | Local tests    | `./bin/run-tests.sh` (exit 0 GREEN · 1 RED · 2 AMBER · 3 FILTERED)                                                     |
-> | Hardware tests | [meshtastic/meshtastic-mcp](https://github.com/meshtastic/meshtastic-mcp) (`MESHTASTIC_FIRMWARE_ROOT` → this checkout) |
-> | Format         | `trunk fmt`                                                                                                            |
-> | Mirror docs    | `AGENTS.md` (short pointer for agents that don't read this file) · `CLAUDE.md` (Claude Code)                           |
->
-> **Need this? It's here.**
->
-> |                                             |                                                            |
-> | ------------------------------------------- | ---------------------------------------------------------- |
-> | General helpers (clamp, UTF-8, string fmt…) | `src/meshUtils.h`                                          |
-> | Logging macros (LOG_DEBUG / INFO / WARN…)   | `src/DebugConfiguration.h`                                 |
-> | New module skeleton                         | inherit `ProtobufModule<T>` in `src/mesh/ProtobufModule.h` |
-> | Observer / event wiring                     | `src/Observer.h`                                           |
-
 This document provides context and guidelines for AI assistants working with the Meshtastic firmware codebase.
 
 ## Project Overview
@@ -55,7 +37,7 @@ MQTT provides a bridge between Meshtastic mesh networks and the internet, enabli
 
 Messages are published/subscribed using a hierarchical topic format:
 
-```text
+```
 {root}/{channel_id}/{gateway_id}
 ```
 
@@ -91,15 +73,15 @@ PKI (Public Key Infrastructure) messages have special handling:
 
 ## Encryption & Key Management
 
-Meshtastic packets on the air are typically encrypted one of two ways: the **per-channel symmetric** layer (AES-CTR with a shared PSK) for broadcasts and channel traffic, and the **per-peer PKI** layer (X25519 ECDH → AES-256-CCM) for direct messages and remote admin. A channel with a 0-byte PSK (or Ham mode, which wipes PSKs) transmits cleartext - see the size table below. Both are implemented in `src/mesh/CryptoEngine.cpp`; the send/receive dispatch lives in `src/mesh/Router.cpp`; admin authorization lives in `src/modules/AdminModule.cpp`.
+Meshtastic packets on the air are typically encrypted one of two ways: the **per-channel symmetric** layer (AES-CTR with a shared PSK) for broadcasts and channel traffic, and the **per-peer PKI** layer (X25519 ECDH → AES-256-CCM) for direct messages and remote admin. A channel with a 0-byte PSK (or Ham mode, which wipes PSKs) transmits cleartext — see the size table below. Both are implemented in `src/mesh/CryptoEngine.cpp`; the send/receive dispatch lives in `src/mesh/Router.cpp`; admin authorization lives in `src/modules/AdminModule.cpp`.
 
 ### High-level model
 
-- **Channels** are symmetric rooms: anyone with the PSK can read any message on the channel. Channel 0 is the "primary" channel and ships with the short-form default PSK on factory devices, forming the public mesh most users join. (The LoRa modem preset `LONG_FAST` lives on `config.lora.modem_preset` and is an independent field - don't conflate "channel 0 default PSK" with the modem preset name.)
+- **Channels** are symmetric rooms: anyone with the PSK can read any message on the channel. Channel 0 is the "primary" channel and ships with the short-form default PSK on factory devices, forming the public mesh most users join. (The LoRa modem preset `LONG_FAST` lives on `config.lora.modem_preset` and is an independent field — don't conflate "channel 0 default PSK" with the modem preset name.)
 - **DMs** addressed to a single node require PKI so that other holders of the channel PSK can't read them. Outside Ham mode, Meshtastic does not fall back to channel-symmetric encryption when the destination public key is unknown.
 - **Remote admin** is a DM carrying an `AdminMessage`. The receiver only acts on it if the sender's public key is on its allowlist (`config.security.admin_key[0..2]`).
-- **Ham mode** (`owner.is_licensed=true`, where `owner` is the local `meshtastic_User` record) disables PKI entirely and sends cleartext - FCC Part 97 prohibits encryption on amateur bands.
-- **No ratchet, no session.** Every packet is encrypted from scratch - a stateless design that matches the high-loss, store-and-forward nature of LoRa.
+- **Ham mode** (`owner.is_licensed=true`, where `owner` is the local `meshtastic_User` record) disables PKI entirely and sends cleartext — FCC Part 97 prohibits encryption on amateur bands.
+- **No ratchet, no session.** Every packet is encrypted from scratch — a stateless design that matches the high-loss, store-and-forward nature of LoRa.
 
 ### Symmetric channel encryption (AES-CTR)
 
@@ -122,151 +104,40 @@ Meshtastic packets on the air are typically encrypted one of two ways: the **per
 
 - **Keypair**: Curve25519 (aka X25519), 32-byte public + 32-byte private. Stored in `config.security.public_key` / `private_key`; the public half is mirrored into `owner.public_key` so it rides along in NodeInfo broadcasts and propagates through the mesh like any other identity field.
 - **Key generation** (`generateKeyPair`): stirs `HardwareRNG::fill()` (64 B from platform TRNG when available), the 16-byte `myNodeInfo.device_id`, and a call to `random()` into the rweather/Crypto library's software RNG, then `Curve25519::dh1`. `regeneratePublicKey` recomputes the public half from a known private (used when restoring from backup).
-- **Keygen entry points**: at boot, `NodeDB` calls `generateKeyPair` (or `regeneratePublicKey` when a stored private key is present and passes a low-entropy check) **directly** when `!owner.is_licensed` and `config.lora.region != UNSET`. `ensurePkiKeys` wraps the same logic for runtime/admin flows - it's the path `AdminModule::handleSetConfig` runs when first assigning a valid region or when security config is written; **do not assume it's the universal boot-time gate**, because the NodeDB path bypasses it.
+- **Keygen entry points**: at boot, `NodeDB` calls `generateKeyPair` (or `regeneratePublicKey` when a stored private key is present and passes a low-entropy check) **directly** when `!owner.is_licensed` and `config.lora.region != UNSET`. `ensurePkiKeys` wraps the same logic for runtime/admin flows — it's the path `AdminModule::handleSetConfig` runs when first assigning a valid region or when security config is written; **do not assume it's the universal boot-time gate**, because the NodeDB path bypasses it.
 - **Handshake**: `Curve25519::dh2(local_private, remote_public) → 32-byte shared secret → SHA-256 → 32-byte AES-256 key`. Recomputed per packet. The SHA-256 step is effectively a KDF over the raw ECDH output.
-- **Cipher**: AES-256-CCM via `aes_ccm_ae` / `aes_ccm_ad` (`src/mesh/aes-ccm.cpp`). MAC length (the `M` parameter) is **8 bytes**. No AAD - the MAC covers ciphertext only.
+- **Cipher**: AES-256-CCM via `aes_ccm_ae` / `aes_ccm_ad` (`src/mesh/aes-ccm.cpp`). MAC length (the `M` parameter) is **8 bytes**. No AAD — the MAC covers ciphertext only.
 - **Nonce (13 bytes / 104 bit)**: `aes_ccm_ae`/`aes_ccm_ad` use a 13-byte CCM nonce (`L = 2` is hardcoded in `src/mesh/aes-ccm.cpp`), not a 16-byte nonce. For PKI packets, `CryptoEngine::initNonce(fromNode, packetNum, extraNonce)` starts from the usual packet-derived nonce material, then overwrites nonce bytes `4..7` with a fresh 32-bit `extraNonce = random()`. The effective nonce bytes are therefore: bytes `0..3` = `packet_id`, bytes `4..7` = transmitted `extraNonce`, bytes `8..11` = `from_node`, byte `12` = `0x00`. The receiver reconstructs the same 13-byte nonce from the packet metadata plus the appended `extraNonce`.
 - **Wire overhead**: 12 bytes appended to the ciphertext = 8-byte MAC ‖ 4-byte extraNonce. Defined as `MESHTASTIC_PKC_OVERHEAD = 12` in `src/mesh/RadioInterface.h`. Only the 4-byte `extraNonce` is sent; the rest of the 13-byte CCM nonce is reconstructed from packet fields as described above. The Router's send path checks this overhead against `MAX_LORA_PAYLOAD_LEN` before committing to PKI.
-- **Send selection** (`Router::send`): the sender enters the PKI path when **all** hold - we're the originator AND not Ham mode AND not Portduino simradio AND not on the `serial`/`gpio` channels (unless the packet is already marked `pki_encrypted`) AND `config.security.private_key.size == 32` AND destination is a single node (not broadcast) AND the portnum isn't infrastructure. `TRACEROUTE_APP`, `NODEINFO_APP`, `ROUTING_APP`, and `POSITION_APP` are routed through channel encryption even when DMed (these need to be readable by relaying peers). Once on the PKI path, if the destination's public key isn't in our NodeDB the send **fails** with `PKI_SEND_FAIL_PUBLIC_KEY` - it does not silently fall back to channel encryption. If the client explicitly set `pki_encrypted=true` and any condition blocks PKI, the send fails with `PKI_FAILED`.
+- **Send selection** (`Router::send`): the sender enters the PKI path when **all** hold — we're the originator AND not Ham mode AND not Portduino simradio AND not on the `serial`/`gpio` channels (unless the packet is already marked `pki_encrypted`) AND `config.security.private_key.size == 32` AND destination is a single node (not broadcast) AND the portnum isn't infrastructure. `TRACEROUTE_APP`, `NODEINFO_APP`, `ROUTING_APP`, and `POSITION_APP` are routed through channel encryption even when DMed (these need to be readable by relaying peers). Once on the PKI path, if the destination's public key isn't in our NodeDB the send **fails** with `PKI_SEND_FAIL_PUBLIC_KEY` — it does not silently fall back to channel encryption. If the client explicitly set `pki_encrypted=true` and any condition blocks PKI, the send fails with `PKI_FAILED`.
 - **Receive selection** (`Router::perhapsDecode`): try PKI decrypt first when `channel == 0` AND `isToUs(p)` AND not broadcast AND both peers have public keys in NodeDB AND `rawSize > MESHTASTIC_PKC_OVERHEAD`. On success the packet gets `pki_encrypted=true` stamped and the sender's public key copied into `p->public_key` for downstream authorization.
 
 ### Remote admin authorization
 
 Implemented in `src/modules/AdminModule.cpp` → `handleReceivedProtobuf`. The authorization check runs in this order:
 
-1. **Response messages** - if `messageIsResponse(r)` is true (the payload is a response to one of our earlier admin requests), it's accepted without any further check. The in-file comment flags this as a known-untightened gap: a stricter implementation would remember which `public_key` we last queried and reject responses that don't match.
-2. **Local admin** - `mp.from == 0` (phone app over BLE, serial CLI, internal module); never travels over the air. **Rejected** if `config.security.is_managed` is true, because managed devices expect admin to arrive over the air through an authorized remote path.
-3. **Legacy admin channel (deprecated)** - the packet arrived on a channel named literally `"admin"`. Gated by `config.security.admin_channel_enabled`; returns `NOT_AUTHORIZED` if the flag is false. Kept for backward compatibility; new deployments should use PKI admin.
-4. **PKI admin (preferred for remote)** - `mp.pki_encrypted == true` AND `mp.public_key` matches one of `config.security.admin_key[0..2]` (up to three authorized 32-byte Curve25519 public keys, typically copied from the admin node's own `user.public_key`).
+1. **Response messages** — if `messageIsResponse(r)` is true (the payload is a response to one of our earlier admin requests), it's accepted without any further check. The in-file comment flags this as a known-untightened gap: a stricter implementation would remember which `public_key` we last queried and reject responses that don't match.
+2. **Local admin** — `mp.from == 0` (phone app over BLE, serial CLI, internal module); never travels over the air. **Rejected** if `config.security.is_managed` is true, because managed devices expect admin to arrive over the air through an authorized remote path.
+3. **Legacy admin channel (deprecated)** — the packet arrived on a channel named literally `"admin"`. Gated by `config.security.admin_channel_enabled`; returns `NOT_AUTHORIZED` if the flag is false. Kept for backward compatibility; new deployments should use PKI admin.
+4. **PKI admin (preferred for remote)** — `mp.pki_encrypted == true` AND `mp.public_key` matches one of `config.security.admin_key[0..2]` (up to three authorized 32-byte Curve25519 public keys, typically copied from the admin node's own `user.public_key`).
 5. **Fallthrough** → `NOT_AUTHORIZED`.
 
-On top of authorization, any remote admin message that **mutates** state (not a request, not a response) also has to pass a session-key check (`checkPassKey`): the client must first pull a fresh 8-byte `session_passkey` via `get_admin_session_key_request`, then echo that passkey back in the mutating message. The device rotates the passkey after 150 s and rejects values older than 300 s - a narrow anti-replay window on top of the PKI layer.
+On top of authorization, any remote admin message that **mutates** state (not a request, not a response) also has to pass a session-key check (`checkPassKey`): the client must first pull a fresh 8-byte `session_passkey` via `get_admin_session_key_request`, then echo that passkey back in the mutating message. The device rotates the passkey after 150 s and rejects values older than 300 s — a narrow anti-replay window on top of the PKI layer.
 
-`config.security.is_managed = true` disables **local** admin writes (`mp.from == 0` is rejected). It does not by itself force every admin action through PKI - the legacy `"admin"` channel still authorizes remote admin when `config.security.admin_channel_enabled == true`. The AdminModule refuses to persist `is_managed=true` unless at least one `admin_key` is populated - a deliberate guard against operators locking themselves out.
+`config.security.is_managed = true` disables **local** admin writes (`mp.from == 0` is rejected). It does not by itself force every admin action through PKI — the legacy `"admin"` channel still authorizes remote admin when `config.security.admin_channel_enabled == true`. The AdminModule refuses to persist `is_managed=true` unless at least one `admin_key` is populated — a deliberate guard against operators locking themselves out.
 
 ### Key-rotation hazards (actions that invalidate peers)
 
 - **`factory_reset_device`** (the "full" variant, calls `NodeDB::factoryReset(eraseBleBonds=true)`) → **wipes** the X25519 private key; a fresh keypair is generated on the next region-set. Every existing peer holds the old public key, so DMs to this node silently fail PKI decrypt until every peer re-exchanges NodeInfo.
 - **`factory_reset_config`** (the "partial" variant, calls `NodeDB::factoryReset()` with `eraseBleBonds=false`) → **preserves** the X25519 private key in `installDefaultConfig(preserveKey=true)`; the public key is zeroed and gets rebuilt from the preserved private key on the next boot via the NodeDB path's `regeneratePublicKey` call. Identity is preserved and the mesh does not need to re-exchange keys.
 - **`region=UNSET → valid region`** → `ensurePkiKeys` runs inside the same `handleSetConfig` path; missing keys get generated at that moment.
-- **Ham mode transitions** - entering Ham mode (`user.is_licensed=true`) runs `Channels::ensureLicensedOperation`, which **wipes every channel PSK** (all traffic becomes cleartext) and disables the legacy admin channel. The X25519 private key is preserved on the device but not used because `Router::send` skips PKI when `owner.is_licensed` is true. Leaving Ham mode re-enables PKI with the preserved keypair but does not restore the wiped channel PSKs - the operator has to re-set them.
+- **Ham mode transitions** — entering Ham mode (`user.is_licensed=true`) runs `Channels::ensureLicensedOperation`, which **wipes every channel PSK** (all traffic becomes cleartext) and disables the legacy admin channel. The X25519 private key is preserved on the device but not used because `Router::send` skips PKI when `owner.is_licensed` is true. Leaving Ham mode re-enables PKI with the preserved keypair but does not restore the wiped channel PSKs — the operator has to re-set them.
 - **Channel 0 PSK change** → every peer must re-learn the channel hash; cached NodeInfo becomes temporarily unreachable until the next broadcast.
 - **`security.private_key` blanked via admin** → regenerates both halves (unless in Ham mode) and propagates the new public key via NodeInfo.
 
-## NodeDB Layout (v25)
-
-`DEVICESTATE_CUR_VER = 25`, `DEVICESTATE_MIN_VER = 24`. The on-device NodeDB was split in v25 into a slim header table plus four optional satellite stores. Older v24 saves auto-migrate at boot. Old training-data instincts (`node->user.long_name`, `node->position.latitude_i`, `node->is_favorite`, `node->device_metrics.battery_level`) are wrong now - the fields aren't there. Read this section before touching anything that walks `nodeDB->meshNodes`.
-
-### Slim `NodeInfoLite`
-
-`UserLite` is flattened onto `NodeInfoLite` (no nested sub-message); `position` and `device_metrics` are removed entirely (tags reserved). MAC address is dropped. Long names are capped at 25 chars (`max_size:25` in `deviceonly.options`); `hw_model` and `role` are `int_size:8`. Encoded size dropped from ~166 B → ~105 B per node.
-
-Booleans are bit-packed into `NodeInfoLite.bitfield`. **Do not read or write the bits directly** - use the inline helpers in `src/mesh/NodeDB.h`:
-
-```cpp
-nodeInfoLiteHasUser(n)                  // bit 5 - user fields populated
-nodeInfoLiteIsFavorite(n)               // bit 3
-nodeInfoLiteIsIgnored(n)                // bit 4
-nodeInfoLiteIsMuted(n)                  // bit 1
-nodeInfoLiteIsLicensed(n)               // bit 6 - Ham mode peer
-nodeInfoLiteIsKeyManuallyVerified(n)    // bit 0
-nodeInfoLiteHasIsUnmessagable(n)        // bit 8 - "is_unmessagable was sent"
-nodeInfoLiteIsUnmessagable(n)           // bit 7
-// via_mqtt is bit 2 (mask exposed; predicate uses the mask directly)
-
-nodeInfoLiteSetBit(n, NODEINFO_BITFIELD_IS_FAVORITE_MASK, true);  // setter
-```
-
-### Satellite stores
-
-Four `std::unordered_map<NodeNum, …>` members on `NodeDB`, each gated by its own build flag:
-
-| Map               | Value type                      | Build flag                         |
-| ----------------- | ------------------------------- | ---------------------------------- |
-| `nodePositions`   | `meshtastic_PositionLite`       | `MESHTASTIC_EXCLUDE_POSITIONDB`    |
-| `nodeTelemetry`   | `meshtastic_DeviceMetrics`      | `MESHTASTIC_EXCLUDE_TELEMETRYDB`   |
-| `nodeEnvironment` | `meshtastic_EnvironmentMetrics` | `MESHTASTIC_EXCLUDE_ENVIRONMENTDB` |
-| `nodeStatus`      | `meshtastic_StatusMessage`      | `MESHTASTIC_EXCLUDE_STATUSDB`      |
-
-Defaults are ON (i.e., maps **excluded**) for STM32WL only - see `src/mesh/mesh-pb-constants.h`. On every other arch all four maps are present. When excluded, the map member is absent and the corresponding accessors return `false`.
-
-All four maps are guarded by **`mutable concurrency::Lock satelliteMutex`** - concurrent access from receive threads, the phone API state machine, and the renderer is the rule, not the exception.
-
-### Accessor convention
-
-**Never hand out pointers into the maps.** Use the copy-out accessors on `NodeDB`:
-
-```cpp
-bool copyNodePosition(NodeNum, meshtastic_PositionLite &out)       const;
-bool copyNodeTelemetry(NodeNum, meshtastic_DeviceMetrics &out)     const;
-bool copyNodeEnvironment(NodeNum, meshtastic_EnvironmentMetrics &out) const;
-bool copyNodeStatus(NodeNum, meshtastic_StatusMessage &out)        const;
-```
-
-Each takes the lock, copies the value if present, returns `false` if the entry is absent or the DB is excluded. Pass-by-out-param is deliberate - pointer-style accessors would invite UAF and lock-leak bugs across the renderer. The "has any X" convenience predicates (`hasValidPosition` etc.) are implemented in terms of these.
-
-Writers go through `setNodeStatus`, `updatePosition`, `updateTelemetry` (which dispatches on `which_variant` for device vs environment metrics) - these own the lock and the eviction hooks.
-
-### Eviction
-
-Every code path that drops a node from the header table must also evict the satellites. The single chokepoint is `eraseNodeSatellites(NodeNum)`; it's already called from `getOrCreateMeshNode`'s oldest-boring eviction, `demoteOldestHotNodesToWarm` (the over-cap warm-tier migration), `removeNodeByNum`, both branches of `resetNodes`, `cleanupMeshDB`, `addFromContact`'s ignored-branch, and `AdminModule`'s `set_ignored_node`. Add new eviction sites here, not by calling `.erase()` directly. (Note: `enforceSatelliteCaps`/`evictSatelliteOverCap` call `.erase()` directly on purpose - that's a satellite-only cap trim where the node _stays_ in the header, a different operation from this chokepoint.)
-
-### Warm tier (long-tail identity)
-
-On every arch except STM32WL and bare nRF52832 (`WARM_NODE_COUNT > 0`), a node evicted from the header table is not forgotten outright: `WarmNodeStore` (`src/mesh/WarmNodeStore.{h,cpp}`) keeps a 40 B `{num, last_heard, public_key}` record per evicted node - primarily so PKI DMs to/from a long-tail node keep decrypting without re-running a NodeInfo exchange (the rest of `NodeInfoLite` rebuilds from traffic in seconds).
-
-- **Write:** `getOrCreateMeshNode`'s eviction and `demoteOldestHotNodesToWarm` (the over-cap boot migration) call `warmStore.absorb(num, last_heard, key)` _before_ the node leaves the header.
-- **Read-back:** `getOrCreateMeshNode` calls `warmStore.take()` to rehydrate `last_heard` + key when a warm node is re-admitted; `copyPublicKey()` falls back to the warm tier so the PKI send path finds keys for evicted peers.
-- **Persistence:** nRF52840 uses a 12 KB raw-flash record-ring at `0xEA000` (below LittleFS; append + replay + compact-on-rotate, link-guarded by `nrf52840_s140_v7.ld` and `extra_scripts/nrf52_warm_region.py`). Everywhere else: a `/prefs/warm.dat` snapshot flushed by `saveIfDirty()` on the node-DB save cadence.
-- **Tunables** (`mesh-pb-constants.h`): `WARM_NODE_COUNT` (per-arch; `0` disables the tier) and `MAX_NUM_NODES` (hot cap - 120 on nRF52840/generic ESP32 to fit the 28 KB LittleFS; ESP32-S3 picks 100/200/250 at boot from its flash size). Verbose migration/self-care tracing routes through `LOG_MIGRATION`, gated by `MESHTASTIC_NODEDB_MIGRATION_VERBOSE`.
-- **`MAX_NUM_NODES` on native is not in that header and is not a constant.** `variants/native/portduino{,-buildroot}/variant.h` define it as `portduino_config.MaxNodes` - resolved at **runtime**, default **200**, overridable per-host with `General: MaxNodes` in the portduino YAML. `variant.h` is reached first, so the `ARCH_PORTDUINO` branch in `mesh-pb-constants.h` never fires; it is now `#error`-guarded rather than holding a plausible-looking `250`. Reading 250 there yields a protected-node cap of 248 when the real one is 198 (`numProtectedNodes() < MAX_NUM_NODES - 2`), which has already produced one wrong diagnosis. The separate 250 in `NodeDB::getMaxNodesAllocatedSize()` is `NODEDB_MIGRATION_LOAD_CEILING`, a decode allowance for files from larger-cap firmware - not a cap.
-
-### Satellite caps
-
-Only the freshest `MAX_SATELLITE_NODES` nodes keep satellite payloads; the rest of the header table carries just the `NodeInfoLite`. The cap is **per-platform**: 40 on RAM-constrained parts (nRF52840, generic ESP32) since the four maps live in internal SRAM (not PSRAM, ~408 B/node across the four), and 250 on flash-rich hosts (ESP32-S3, portduino) so every hot node can carry rich data as before the cap existed. `enforceSatelliteCaps()` trims each map to the cap on load (returns whether it trimmed); `evictSatelliteOverCap()` trims before each insert. Eviction is by the owning node's hot `last_heard` (stalest first, demoted/absent nodes rank as `last_heard==0`); self is never trimmed.
-
-### On-boot self-care
-
-`NodeDB::nodeDBSelfCare()` runs once identity is established (the constructor after key (re)gen, and `reloadFromDisk()` - _not_ inside `loadFromDisk`, where `getNodeNum()` is still 0). It confirms self is present (warns if a non-empty DB is missing us - a foreign/over-cap file), pins self to index 0, demotes/trims only **non-self** overflow into the warm tier, then rewrites `nodes.proto` **once** and only if it healed something - and never while encrypted storage is locked (it would persist placeholder defaults). `loadFromDisk` deliberately leaves the loaded store untrimmed for this pass.
-
-### Sync flow: thin NodeInfo + post-COMPLETE_ID replay (no opt-in)
-
-There is no capability flag and no special "gradient" nonce. The **default** sync flow is:
-
-1. Config / module-config / channel / metadata segments (same as before).
-2. `STATE_SEND_OWN_NODEINFO` - **our own** NodeInfo, still bundled with our position and device_metrics (because the replay snapshot excludes our own NodeNum). Emitted via `ConvertToNodeInfo(lite)`.
-3. `STATE_SEND_OTHER_NODEINFOS` - every other peer's NodeInfo, **always thin** (no `position`, no `device_metrics`). Emitted via `ConvertToNodeInfoThin(lite)`.
-4. `STATE_SEND_FILEMANIFEST` → `STATE_SEND_COMPLETE_ID` - the phone sees `config_complete_id` and treats sync as done.
-5. `STATE_SEND_PACKETS` - live mesh packets, with a trailing replay drain interleaved. The replay drain walks four cached satellite stores in order (positions → telemetry → environment → status) and emits each cached entry as an ordinary `MeshPacket` on the matching portnum (`POSITION_APP`, `TELEMETRY_APP` device + environment variants, `NODE_STATUS_APP`). These are indistinguishable on the wire from live mesh traffic, so clients need no special handling - any code that already updates UI on `POSITION_APP` etc. works.
-
-`PhoneAPI::sendConfigComplete()` arms `replayPhase = REPLAY_PHASE_POSITIONS` for default/full sync and `SPECIAL_NONCE_ONLY_NODES`, while `SPECIAL_NONCE_ONLY_CONFIG` skips replay. The drain runs inside `STATE_SEND_PACKETS` via `popReplayPacket()`, lower priority than live traffic. When all four phases drain, `replayPhase` flips back to `REPLAY_PHASE_IDLE` and the snapshot vectors get `shrink_to_fit`ed.
-
-STM32WL and any other build with all four `MESHTASTIC_EXCLUDE_*DB` flags set produces zero replay packets - `popReplayPacket` advances through each phase in microseconds without emitting anything.
-
-Special nonces that still mean something:
-
-- `SPECIAL_NONCE_ONLY_CONFIG` (69420) - skip node sync entirely, just config.
-- `SPECIAL_NONCE_ONLY_NODES` (69421) - skip config segments, jump straight to `STATE_SEND_OWN_NODEINFO`. Still gets the post-COMPLETE_ID replay drain.
-
-There are no other reserved nonces; everything else is a fresh random `want_config_id` from the client.
-
-### v24 → v25 migration
-
-The legacy migration code lives in **`src/mesh/NodeDBLegacyMigration.cpp`**, not in `NodeDB.cpp`. It owns the `meshtastic_NodeDatabase_Legacy` callback and `NodeDB::migrateLegacyNodeDatabase()`. The legacy proto descriptor is `protobufs/meshtastic/deviceonly_legacy.proto` (only included by the migration TU). The boot path peeks the file's leading version tag, runs the migration if `version < 25`, then re-saves in v25 layout. The legacy descriptor is scheduled for removal once `DEVICESTATE_MIN_VER` is bumped.
-
-### Read-site rules of thumb
-
-- Never `node->position.X` / `node->device_metrics.X` - those fields no longer exist. Pull from the satellite map via `copyNodePosition` / `copyNodeTelemetry`.
-- Never `node->user.long_name` - `long_name`, `short_name`, `public_key`, `hw_model`, `role`, `macaddr` (gone), `is_licensed`, `is_unmessagable` are flat on `NodeInfoLite`.
-- Never `node->is_favorite` / `node->is_ignored` / `node->via_mqtt` / `node->is_key_manually_verified` - use the bitfield helpers.
-- Never assume `nodeDB->getMeshNode(num)->position.time` - call `copyNodePosition` and check the return.
-- Don't lock `satelliteMutex` yourself in renderer code; the copy-out accessors already do.
-
-Unit tests for the conversion layer live in `test/test_type_conversions/test_main.cpp` (Unity) - bitfield round-trips, `long_name` truncation, thin-vs-full conversions. Add cases there when extending the schema.
-
 ## Project Structure
 
-```text
+```
 firmware/
 ├── src/                    # Main source code
 │   ├── main.cpp           # Application entry point
@@ -313,44 +184,20 @@ firmware/
 │   └── native/           # Linux/Portduino variants
 ├── protobufs/            # Protocol buffer definitions
 ├── boards/               # Custom PlatformIO board definitions
-├── test/                 # Native unit-test suites (count = the test_* dirs, detected on the fly)
+├── test/                 # Unit tests (12 test suites)
 └── bin/                  # Build and utility scripts
 ```
 
 ## Coding Conventions
 
-### Formatting & the trunk toolchain
-
-`trunk fmt` is the project formatter (`trunk_check` CI rejects unformatted code). For Claude Code users, `.claude/settings.json` ships a PostToolUse hook that runs `trunk fmt --force` on every file the agent writes or edits. The hook is pure sh/grep/sed - no python or jq required - but trunk itself must be able to run:
-
-- Trunk's launcher (`~/.cache/trunk/launcher/trunk`, or `trunk` on PATH) downloads the CLI version pinned in `.trunk/trunk.yaml` on first use and again whenever that pin is bumped. **The launcher needs `curl` or `wget`**; without one it fails with "Cannot download… please install curl or wget", and the hook surfaces that as a warning on every write.
-- No curl/wget available (e.g. a minimal WSL image)? Bootstrap by hand with any Python (PlatformIO bundles one at `~/.platformio/penv/bin/python`): download `https://trunk.io/releases/<ver>/trunk-<ver>-linux-x86_64.tar.gz` and place the `trunk` binary at `~/.cache/trunk/cli/<ver>-linux-x86_64/trunk` (chmod +x), where `<ver>` is the `cli.version` from `.trunk/trunk.yaml`.
-- The hook fails loudly by design (visible warning, non-blocking). Silent no-op formatting hooks hide real breakage - don't re-add `2>/dev/null || true` around the whole thing.
-- More generally: don't assume a stock Linux userland in hooks or helper scripts - minimal WSL/container images may lack `python3`, `curl`, `wget`, and `jq`. Prefer plain sh + coreutils, or PlatformIO's bundled Python for anything heavier.
-
 ### General Style
 
 - Follow existing code style - run `trunk fmt` before commits
 - Prefer `LOG_DEBUG`, `LOG_INFO`, `LOG_WARN`, `LOG_ERROR` for logging
-- **Three logging tiers for diagnostics.** `LOG_TRACE` is the per-packet/per-poll firehose - compiled out by default (`MESHTASTIC_TRACE_LOGGING=1` enables; always on for portduino). Subsystem bring-up detail routes through a per-subsystem gate macro instead, e.g. `LOG_DEBUG_GPS(...)` in `src/gps/GPSLog.h` (`GPS_DEBUG=1` enables; costs no flash when off) - model new subsystem gates on it or on `LOG_MIGRATION` (`src/mesh/WarmNodeStore.h`): `#ifndef` value-default, `#if SYM` value test, `((void)0)` off-branch. Genuine anomalies stay unconditional `LOG_WARN`/`LOG_ERROR`.
-- **Format node IDs and packet IDs as `0x%08x` in logs.** This covers `NodeNum`/`PacketId` and the `uint32_t` packet fields `from`, `to`, `id`, `dest`, `source`, `request_id`, and `node_id`. They are 32-bit, so 8 hex digits is exact - `%08x` never truncates or leaves a value ragged. Do **not** use `%x` (variable width) or `%0x` (a no-op typo for `%08x` - the `0` flag does nothing without a width). User-facing display uses `!%08x` (the `!xxxxxxxx` convention), e.g. `Applet::hexifyNodeNum`.
-- **Do not zero-pad one-byte values to 8.** `next_hop`, `relay_node`, and the next-hop hint are `uint8_t` last-byte route hints, and `channel` is a one-byte hash/index - log these as `0x%x` (or `%d`). Padding a byte to `0x000000ab` falsely implies a full node number. The same goes for I2C addresses, register values, flags/bitmasks, and error/reason codes: they are not IDs, so leave them `0x%x`.
 - Use `assert()` for invariants that should never fail
 - C++17 features are available (`std::optional`, structured bindings, `if constexpr`, etc.)
-- **Keep code comments minimal - one or two lines, max.** Comment only when the _why_ isn't obvious from the code; never restate what the next line does. No multi-paragraph block comments explaining straightforward changes. The diff and commit message carry the rationale; the code carries the behavior.
-- **Documentation does not live in this repo. Do not add it here.** This repository holds firmware code. There is no `docs/` directory - the design documents that used to sit there were published to [meshtastic/meshtastic](https://github.com/meshtastic/meshtastic) in #11488 and the directory was deleted - and it must not come back. Do not create a `.md` file to describe a feature, a configuration surface, an API, a wire format, or a design; write it in the docs repo and link that PR instead. Never leave a write-up behind in the tree: no investigation notes, no mitigation plans, no migration checklists, no "how we got here" narrative, no summaries of what a change did. That is what the PR description and the commit message are for, and they are the only place it belongs. When you do write documentation upstream, write a technical manual, not a novel - what the feature does, the settings it exposes in the user's terms, and the exact API or protocol a client speaks. No story of the debugging journey, no rationale essays, no changelog prose. Concise and factual, as short as the facts allow.
-- **Never compare against `millis()` directly. Use `Throttle`.** `src/mesh/Throttle.h` is the sanctioned way to ask about time, and CI enforces this (`millis-deadline-check` in `.github/workflows/test_native.yml` fails the PR on a new `millis() >` / `< millis()` comparison).
-  - `Throttle::isWithinTimespanMs(lastMs, intervalMs)` - true while still inside the cooldown.
-  - `Throttle::hasElapsed(lastMs, intervalMs)` - its complement, true once the interval has passed (inclusive `>=`). Prefer this to spelling `!isWithinTimespanMs(...)`.
-  - `Throttle::execute(&lastMs, intervalMs, func)` - function-pointer form that updates the timestamp on fire.
-  - `Throttle::deadlinePassed(deadlineMs)` - for a stored absolute deadline that cannot be re-expressed as "interval since an event". Uses an unsigned half-range compare; reads deadlines more than ~24.8 days out as already passed, which no interval in this firmware approaches (the longest is 24 h).
-  - `Throttle::deadlinePassedAt(nowMs, deadlineMs)` - the same test against a caller-supplied `now`, for a loop that snapshots the clock once and then tests many deadlines (`NextHopRouter::doRetransmissions()`). Take the snapshot from `Time::getMillis()`, not `millis()`.
-
-  Raw `millis() > deadline` or `deadline < millis()` is rollover-unsafe: the comparison inverts while the deadline sits on the far side of the 32-bit wrap, so the action fires immediately (losing its whole wait) or blocks for roughly the interval it should have waited - days, for the nRF52 flash-corruption backoff. All five helpers subtract first, so unsigned wraparound cancels out. `Throttle` reads the clock through `Time::getMillis()` (`src/UptimeClock.h`), which means every one of its ~94 call sites is time-injectable - a native test can drive `Time::setTestMillis(0xFFFFFF00)` across the wrap. For _timestamps_ (not deadlines) there is `Time::getMillisMonotonic()` / `Time::getUptimeSecs()` - a 64-bit monotonic uptime read. Readers are pure: they add their own wrap-immune elapsed time to a snapshot published by `Time::serviceMonotonic()`, which the main loop calls every iteration and which is **the only writer**. Never call `serviceMonotonic()` from anywhere else - two writers can count one wrap twice, putting every uptime and wall-clock reading ~49.7 days into the future for the rest of the boot. Not ISR-safe (the snapshot is read under a seqlock); see the contract in `UptimeClock.h`. Deadline and interval checks should still use `Throttle`, which needs no carry state at all.
-
-  **Sentinel hazard.** If a deadline variable also encodes "inactive" - `0` for `rebootAtMsec`, `shutdownAtMsec`, `alertBannerUntil`, `fixHoldEnds`; `UINT32_MAX` for `nagCycleCutoff` - test that sentinel _before_ the elapsed comparison, and match the test to the sentinel actually in use. `if (deadline && Throttle::deadlinePassed(deadline))` covers the `0` family only; `nagCycleCutoff` needs `deadline != UINT32_MAX`, or a separate armed flag as `ExternalNotificationModule` does with `isNagging`. Every sentinel value is arithmetically far in the past, so a correct comparison reads it as "expired" and fires immediately: `rebootAtMsec = -1` meaning "never" is what would have become a reboot loop. Never fold the sentinel into the helper.
-
-  **And decide which way the sentinel should fall.** "Inactive" does not always mean "suppress". At the GPS fix-hold site `fixHoldEnds == 0` means _no hold is in force_, which is exactly when a new hold must be armed - the naive comparison it replaced was `(fixHoldEnds + GPS_THREAD_INTERVAL) < millis()`, always true when nothing was armed. Guarding it with `fixHoldEnds != 0 &&` looks like this rule and inverts the site: nothing re-arms, nothing publishes, and the receiver stays powered until the search timeout. Read the surrounding logic before adding the guard. `fixHoldInForce()` in `src/gps/GPS.cpp` is the worked example - state the predicate positively, so the sentinel has an honest answer, and derive both decisions from it - with `test/test_gps_fix_hold/` pinning both directions.
+- **Keep code comments minimal — one or two lines, max.** Comment only when the _why_ isn't obvious from the code; never restate what the next line does. No multi-paragraph block comments explaining straightforward changes. The diff and commit message carry the rationale; the code carries the behavior.
+- **Use `Throttle` for time-based rate limiting, not raw `millis()` math.** `src/mesh/Throttle.h` provides `Throttle::isWithinTimespanMs(lastMs, intervalMs)` (returns true while inside the cooldown) and `Throttle::execute(&lastMs, intervalMs, func)` (function-pointer form that updates the timestamp on fire). Use these for any "did N ms pass since X" check — raw `millis() > lastMs + N` is rollover-unsafe (breaks after ~49.7 days) and inconsistent with the rest of the codebase. The helpers compute `now - lastMs` with unsigned subtraction, which wraps correctly.
 
 ### Naming Conventions
 
@@ -440,7 +287,7 @@ Multiple display driver families in `src/graphics/`:
 
 **InkHUD** (`src/graphics/niche/InkHUD/`) is an event-driven e-ink UI framework:
 
-- Applet-based architecture - modular display tiles
+- Applet-based architecture — modular display tiles
 - Read-only, static display optimized for minimal refreshes and low power
 - Configured per-variant via `nicheGraphics.h`
 - Separate PlatformIO config: `src/graphics/niche/InkHUD/PlatformioConfig.ini`
@@ -497,7 +344,6 @@ Key defines in variant.h:
 - Regenerate with `bin/regen-protos.sh`
 - Message types prefixed with `meshtastic_`
 - Nanopb `.options` files control field sizes and encoding
-- **Never edit or commit files under `src/mesh/generated/`.** They are regenerated from the [`meshtastic/protobufs`](https://github.com/meshtastic/protobufs) submodule by the `update_protobufs.yml` GitHub Action and any hand edits will be overwritten - guaranteed merge conflict on the next sync. To change a wire format, open a PR against the protobufs repo first; the workflow then re-runs `bin/regen-protos.sh` and opens a PR here with the regenerated sources.
 
 ### Conditional Compilation
 
@@ -517,7 +363,7 @@ Key defines in variant.h:
 
 ## Build System
 
-### Agent Tooling Baseline
+## Agent Tooling Baseline
 
 Mirror counterpart: `AGENTS.md` under **Agent Tooling Baseline**.
 
@@ -570,10 +416,9 @@ pio run -e native-macos       # Build headless macOS meshtasticd (Homebrew prere
 
 1. Create directory under `variants/<arch>/<name>/`
 2. Add `variant.h` with pin definitions and hardware capability defines
-3. Add `platformio.ini` with build config - use `extends` to reference common base (e.g., `esp32s3_base`)
-4. Set `board_level` (required - `release` for a normal variant; see "Build Matrix Generation")
-5. Set `custom_meshtastic_support_level` (1-3) and the other `custom_meshtastic_*` metadata
-6. For e-ink displays, add `nicheGraphics.h` for InkHUD configuration
+3. Add `platformio.ini` with build config — use `extends` to reference common base (e.g., `esp32s3_base`)
+4. Set `custom_meshtastic_support_level = 1` (PR builds) or `2` (merge builds)
+5. For e-ink displays, add `nicheGraphics.h` for InkHUD configuration
 
 ### Adding a New Telemetry Sensor
 
@@ -657,16 +502,11 @@ The CI uses `bin/generate_ci_matrix.py` to dynamically select which targets to b
 ./bin/generate_ci_matrix.py all --level pr
 ```
 
-Every variant env **must** declare a `board_level` in its `platformio.ini`; the matrix
-generator exits non-zero if any env is missing it or uses an unrecognized value:
+Variants can specify their support level in `platformio.ini`:
 
-- `board_level = pr` - Smallest subset, built on every PR (and in every larger matrix)
-- `board_level = release` - The full release matrix, built on push / schedule / `workflow_dispatch`
-- `board_level = extra` - Opt-in only, built when explicitly requested via `--level extra`
-
-`custom_meshtastic_support_level` (1-3) is **not** part of this filtering. It is variant
-metadata that `bin/platformio-custom.py` emits as `supportLevel` in the generated
-hardware list; changing it does not change which targets CI builds.
+- `custom_meshtastic_support_level = 1` - Actively supported, built on every PR
+- `custom_meshtastic_support_level = 2` - Supported, built on merge to main branches
+- `board_level = extra` - Extra builds, only on full releases
 
 ### Running Workflows Locally
 
@@ -676,130 +516,34 @@ Most workflows can be triggered manually via `workflow_dispatch` for testing.
 
 ### Native unit tests (C++)
 
-Unit tests in `test/` directory. The canonical suite count is detected on the fly: the `test_*` directories under `test/` are the register, and `bin/run-tests.sh` cross-checks the suites that actually ran against them on every full run. **Never state the count as a literal anywhere** - it is whatever `test/test_*` contains right now. In CI, the `suite-shrinkage-check` job (`test_native.yml`) fails a PR that loses a `test_*` directory relative to its merge base unless the suite is named in the PR title, body, or a commit message - deleting a suite therefore requires saying so. The list below is a partial description of what suites cover, not an inventory:
+Unit tests in `test/` directory with 12 test suites:
 
-- `test_admin_radio/` - LoRa region/config validation, AdminModule dispatch, node-DB metadata saves
-- `test_fscommon_getfiles/` - bounded file-manifest walk (cap, depth, truncation reporting)
-- `test_atak/` - ATAK integration
 - `test_crypto/` - Cryptography
-- `test_default/` - Default configuration
-- `test_hop_scaling/` - Hop scaling histogram and required-hop logic
-- `test_http_content_handler/` - HTTP handling
-- `test_mac_from_string/` - MAC address parsing
+- `test_mqtt/` - MQTT integration
+- `test_radio/` - Radio interface
 - `test_mesh_module/` - Module framework
 - `test_meshpacket_serializer/` - Packet serialization
-- `test_mqtt/` - MQTT integration
-- `test_nexthop_routing/` - Next-hop routing logic
-- `test_nodedb_blocked/` - NodeDB blocked-node handling
-- `test_packet_history/` - Packet history tracking
-- `test_packet_signing/` - Packet signing
-- `test_position_module/` - Position module behaviour
-- `test_position_precision/` - Position precision helpers
-- `test_radio/` - Radio interface
-- `test_rtc/` - RTC / time handling
-- `test_serial/` - Serial communication
-- `test_tak_config/` - TAK (ATAK) team/role value fidelity through set/save/load/get
-- `test_module_config/` - every ModuleConfig submessage survives admin set -> save -> load -> get
-- `test_traffic_management/` - Traffic management (dedup, rate-limit, hop-trim, role exceptions)
 - `test_transmit_history/` - Retransmission tracking
-- `test_type_conversions/` - NodeDB v25 type conversion (bitfield round-trips, NodeInfoLite)
-- `test_utf8/` - UTF-8 utilities
-- `test_warm_store/` - Warm-tier node store
+- `test_atak/` - ATAK integration
+- `test_default/` - Default configuration
+- `test_http_content_handler/` - HTTP handling
+- `test_serial/` - Serial communication
 
-**Preferred run command - `bin/run-tests.sh`** (defaults to the `coverage` env; emits a machine-readable verdict on the final line; new `test_*` directories are picked up automatically):
-
-```bash
-./bin/run-tests.sh                             # all suites
-./bin/run-tests.sh -f test_traffic_management  # single suite (yields FILTERED, not GREEN)
-```
-
-**The harness is Linux-only, and rejects anything else.** `bin/run-tests.sh` needs bash 4+ and GNU coreutils/find (`find -printf`, `md5sum`, `-executable`), so it exits 2 on a non-Linux `uname` rather than degrade quietly - a state check that silently mis-hashes a sandbox still prints a verdict, and that verdict would be worthless. The `native-macos` PlatformIO env is a **build** target for `meshtasticd`, not a test host. On macOS or Windows use `./bin/test-native-docker.sh`.
-
-**Sanitizer coverage is per env, and only one env has any.** `coverage` (the default) adds gcov + ASan/LSan on top of `native`. **`native` itself has none** - verified, zero ASan symbols in the built binary. A `-e native` run is _not_ sanitized, so do not reason from "run-tests.sh uses ASan" when you passed `-e native`.
-
-**A signal name from the runner is not a crash.** `exit(UNITY_END())` returns the failure count, and PlatformIO's native runner renders a non-zero exit code as a POSIX signal - 4 failures prints `Program received signal SIGILL`, 5 prints `SIGTRAP`, and the suite is reported `[ERRORED]` instead of `[FAILED]`. Check the exit code against the failure count before theorising about memory bugs; confirm any real crash under a debugger.
-
-**Suite order is randomisable.** `./bin/run-tests.sh --shuffle` runs suites in a seeded random order; `--seed <n>` replays one. The seed defaults to the commit SHA (deterministic per commit, varied across commits), is printed at the start and on the `RESULT:` line, and the full order is printed on failure. CI shuffles its area order the same way, seeded from `GITHUB_SHA`. A single green seed is not evidence of order independence.
-
-**`-f` is not a gate.** A filtered run can pass while a full run fails, because filtering removes the suites that _create_ the state a later suite trips over. Iterate with `-f`; gate on a full run.
-
-Exit codes and verdicts (exact counts will vary; examples below are illustrative):
-
-| Exit | Verdict    | Meaning                                                                                                                                                                                                              |
-| ---- | ---------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| 0    | `GREEN`    | All canonical suites ran, all passed, no ignored test cases                                                                                                                                                          |
-| 1    | `RED`      | At least one failure, build error, or sanitizer fault                                                                                                                                                                |
-| 2    | `AMBER`    | All that ran passed, but something was lost or unexplained: a suite silently went missing on a full run, individual test cases were skipped (`TEST_IGNORE`), or a suite left behind shared state it does not declare |
-| 3    | `FILTERED` | A `-f` run completed cleanly; suites outside the filter were intentionally not run                                                                                                                                   |
-
-Examples - exact counts will vary by suite count and env:
-
-```text
-# GREEN: all suites ran and passed
-RESULT: GREEN N/N suites passed, all CLEAN
-
-# RED: real test failure
-RESULT: RED 1 failed
-
-# RED: sanitizer exit-time abort (all tests passed but process aborted at exit)
-RESULT: RED exit-time abort (tests passed; likely sanitizer - see hint above)
-
-# AMBER: a suite silently went missing on a full run
-RESULT: AMBER 23/24 suites ran (missing: test_radio) - all that ran passed
-
-# FILTERED: single suite run completed cleanly
-RESULT: FILTERED 1/24 suites ran (not run: test_admin_radio test_atak …) - filtered: test_serial
-```
-
-> **Copilot interface note:** When running tests via the Copilot chat interface, edits made through the chat may not be reflected in the on-disk files that the test binary reads. If tests pass in chat but fail locally (or vice versa), verify the files on disk match what you expect before trusting the result. Always confirm with a local terminal run.
-
-Raw `pio test` (no sanitizers, no verdict logic) - use only when you need to override the env:
-
-```bash
-~/.platformio/penv/bin/python -m platformio test -e native -f test_your_suite > /tmp/test_out.txt 2>&1
-grep -E 'error:|PASS|FAIL|succeeded|failed' /tmp/test_out.txt
-tail -15 /tmp/test_out.txt
-```
-
-Do **not** pipe `pio test` - line-buffering makes the terminal appear hung and hides build errors.
+Run with: `pio test -e native`
 
 Simulation testing: `bin/test-simulator.sh`
 
 Quick entry point for new test modules: `test/README.md` (native unit-test authoring guide, skeleton, pitfalls, and setup checklist).
 
-### Shared state: every suite gets a clean sandbox
+### Hardware-in-the-loop tests (`mcp-server/tests/`)
 
-Each suite runs inside its own scratch `$HOME` (`bin/pio-test-isolate.sh`, wired in per env as `test_testing_command`, so a bare `pio test` and CI get it too). **State never crosses a suite boundary.** Mutation _inside_ a suite is free; carrying state _out_ of one is impossible by construction, not by policy.
-
-The state in question lives in `~/.portduino/default/prefs/` - `nodes.proto`, `config.proto`, `channels.proto`, `module.proto`, `device.proto`, `warm.dat`, `transmit_history.dat`. `NodeDB`'s constructor calls `loadFromDisk()`, so any suite that constructs one reads it, and several `NodeDB` paths (`removeNodeByNum()`, `resetNodes()`, `nodeDBSelfCare()`, and the constructor when the file is absent) write it without being asked.
-
-Two orthogonal axes: **PASS/FAIL x CLEAN/DIRTY**.
-
-- **CLEAN** - nothing changed, or everything that changed is declared.
-- **DIRTY** - an undeclared path changed. Graded **AMBER**: with isolation in place it means "undeclared", not "dangerous".
-- **MISSING** - a declared write did not happen. A warning only; it catches persistence that silently stopped working.
-
-Declare deliberate writes in **`test/state-manifest.tsv`** - one central file, `<suite>` / `<flags>` / `<reason>`, with the reason mandatory and reviewed on change. Central so every opt-out is visible in one diffable list; per-suite files hide growth. `run-tests.sh` prints how many suites declare non-default handling on every run.
-
-| Flag              | Meaning                                                                                                                                                                                                     |
-| ----------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| _(no entry)_      | the default: fresh state in, contents discarded out                                                                                                                                                         |
-| `writes=<a,b>`    | files this suite mutates on purpose; matched on the path relative to the sandbox `$HOME` or just the basename                                                                                               |
-| `state=per-suite` | state persists across this suite's own test cases (persistence round-trips, migration ladders). Only the suite boundary is checked; the default is per-test, which names the exact test that dirtied things |
-
-No flag grants cross-suite carry. A suite that needs another suite's output needs an explicit fixture, not inheritance.
-
-`./bin/run-tests.sh --write-manifest` prints the entries a run would need, for a human to paste and justify - it never applies them, and neither does CI. `bin/test-state-check.sh` is the checker's own self-test: fixtures asserting CLEAN / CLEAN / DIRTY / MISSING, plus the before-empty assertion.
-
-### Hardware-in-the-loop tests ([meshtastic-mcp](https://github.com/meshtastic/meshtastic-mcp))
-
-Separate pytest suite that exercises real USB-connected Meshtastic devices. It now lives in the standalone [meshtastic-mcp](https://github.com/meshtastic/meshtastic-mcp) repo, run against a firmware checkout via `MESHTASTIC_FIRMWARE_ROOT`. See the **MCP Server & Hardware Test Harness** section below for invocation, tier layout, and agent usage rules.
+Separate pytest suite that exercises real USB-connected Meshtastic devices. See the **MCP Server & Hardware Test Harness** section below for invocation, tier layout, and agent usage rules.
 
 ## MCP Server & Hardware Test Harness
 
-The firmware-aware [MCP](https://modelcontextprotocol.io/) server plus its pytest-based integration suite now live in the standalone [meshtastic-mcp](https://github.com/meshtastic/meshtastic-mcp) repo. AI agents that speak MCP get a well-defined tool surface for flashing, configuring, and inspecting physical Meshtastic devices - use it instead of hand-rolling `pio` or `meshtastic --port` calls where possible. The meshtastic-mcp repo's README is the operator-facing setup doc; this section is the agent-facing usage contract.
+The `mcp-server/` directory houses a firmware-aware [MCP](https://modelcontextprotocol.io/) server plus a pytest-based integration suite. AI agents that speak MCP get a well-defined tool surface for flashing, configuring, and inspecting physical Meshtastic devices — use it instead of hand-rolling `pio` or `meshtastic --port` calls where possible. `mcp-server/README.md` is the operator-facing setup doc; this section is the agent-facing usage contract.
 
-The repo registers the server via `.mcp.json` at the repo root - Claude Code / Copilot pick it up automatically and run it through `uvx --from git+https://github.com/meshtastic/meshtastic-mcp meshtastic-mcp`, so the MCP tools work with no local build. To run the pytest hardware harness instead, clone [meshtastic-mcp](https://github.com/meshtastic/meshtastic-mcp) and point `MESHTASTIC_FIRMWARE_ROOT` at this firmware checkout.
+The repo registers the server via `.mcp.json` at the repo root — Claude Code picks it up automatically once `mcp-server/.venv/` is built (`cd mcp-server && python3 -m venv .venv && .venv/bin/pip install -e '.[test]'`).
 
 ### When to use which surface
 
@@ -807,80 +551,70 @@ The repo registers the server via `.mcp.json` at the repo root - Claude Code / C
 | ------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------- |
 | Find a connected device                           | `mcp__meshtastic__list_devices`                                                                                  |
 | Read a live node's config/state                   | `mcp__meshtastic__device_info`, `list_nodes`, `get_config`                                                       |
-| Mutate a device (owner, region, channels, reboot) | `set_owner`, `set_config`, `set_channel_url`, `reboot`, `shutdown`, `factory_reset` - all require `confirm=True` |
+| Mutate a device (owner, region, channels, reboot) | `set_owner`, `set_config`, `set_channel_url`, `reboot`, `shutdown`, `factory_reset` — all require `confirm=True` |
 | Flash firmware to a variant                       | `pio_flash` (any arch) or `erase_and_flash` (ESP32 factory install)                                              |
 | Stream serial logs while debugging                | `serial_open` → `serial_read` loop → `serial_close`                                                              |
 | Administer `userPrefs.jsonc` build-time constants | `userprefs_get`, `userprefs_set`, `userprefs_reset`, `userprefs_manifest`                                        |
-| Run the regression suite                          | `./run-tests.sh` from a meshtastic-mcp checkout (or `/test` slash command)                                       |
+| Run the regression suite                          | `./mcp-server/run-tests.sh` (or `/test` slash command)                                                           |
 | Diagnose a specific device                        | `/diagnose [role]` slash command (read-only)                                                                     |
 | Triage a flaky test                               | `/repro <node-id> [count]` slash command                                                                         |
 
 **One MCP call per port at a time.** `SerialInterface` holds an exclusive OS-level lock on the serial port for its lifetime. If a `serial_*` session is open on `/dev/cu.usbmodem101`, calling `device_info` on the same port will fail fast pointing at the active session. Sequence calls: open → read/mutate → close, then next device. Never parallelize tool calls on the same port.
 
-### MCP tool surface (44 tools)
+### MCP tool surface (43 tools)
 
-Grouped by purpose. Full argument shapes in the meshtastic-mcp repo's README; a few high-value signatures are called out here.
+Grouped by purpose. Full argument shapes in `mcp-server/README.md`; a few high-value signatures are called out here.
 
 - **Discovery & metadata**: `list_devices`, `list_boards`, `get_board`
 - **Build & flash**: `build`, `clean`, `pio_flash`, `erase_and_flash` (ESP32 only), `update_flash` (ESP32 OTA), `touch_1200bps`
 - **Serial sessions** (long-running, 10k-line ring buffer): `serial_open`, `serial_read`, `serial_list`, `serial_close`
 - **Device reads**: `device_info`, `list_nodes`
-- **Device writes**: `set_owner`, `get_config`, `set_config`, `get_channel_url`, `set_channel_url`, `send_text`, `send_input_event` (inject a button/key press via the firmware's InputBroker), `inject_frame` (inject an over-the-air-style frame into the RX pipeline - see below), `set_debug_log_api`; destructive/power-state writes require `confirm=True`: `reboot`, `shutdown`, `factory_reset`
+- **Device writes**: `set_owner`, `get_config`, `set_config`, `get_channel_url`, `set_channel_url`, `send_text`, `send_input_event` (inject a button/key press via the firmware's InputBroker), `set_debug_log_api`; destructive/power-state writes require `confirm=True`: `reboot`, `shutdown`, `factory_reset`
 - **userPrefs admin** (build-time constants, not runtime config): `userprefs_get`, `userprefs_set`, `userprefs_reset`, `userprefs_manifest`, `userprefs_testing_profile`
 - **Vendor escape hatches**: `esptool_chip_info`, `esptool_erase_flash`, `esptool_raw`, `nrfutil_dfu`, `nrfutil_raw`, `picotool_info`, `picotool_load`, `picotool_raw`
 - **USB power control** (via `uhubctl`, per-port PPPS toggle): `uhubctl_list` (read-only), `uhubctl_power(action='on'|'off', confirm=True)`, `uhubctl_cycle(delay_s, confirm=True)`. Target by raw `(location, port)` or by `role` (`"nrf52"`, `"esp32s3"`); role lookup checks `MESHTASTIC_UHUBCTL_LOCATION_<ROLE>` + `_PORT_<ROLE>` env vars first, falls back to VID auto-detection.
-- **Observability** (UI tier + operator ad-hoc): `capture_screen(role, ocr=True)` - grabs a USB-webcam frame of the device OLED and optionally OCRs it. Requires `meshtastic-mcp[ui]` extras (`opencv-python-headless`, `easyocr`) and `MESHTASTIC_UI_CAMERA_DEVICE_<ROLE>` env var; falls through to a 1×1 black PNG `NullBackend` when unconfigured.
+- **Observability** (UI tier + operator ad-hoc): `capture_screen(role, ocr=True)` — grabs a USB-webcam frame of the device OLED and optionally OCRs it. Requires `mcp-server[ui]` extras (`opencv-python-headless`, `easyocr`) and `MESHTASTIC_UI_CAMERA_DEVICE_<ROLE>` env var; falls through to a 1×1 black PNG `NullBackend` when unconfigured.
 
-`confirm=True` is a tool-level gate on top of whatever permission prompt your MCP host shows. **Don't bypass it** by asking the host to auto-approve - it exists specifically because MCP hosts sometimes remember "always allow this tool" and that's dangerous for `factory_reset`, `erase_and_flash`, `uhubctl_power(action='off')`, and `uhubctl_cycle`.
+`confirm=True` is a tool-level gate on top of whatever permission prompt your MCP host shows. **Don't bypass it** by asking the host to auto-approve — it exists specifically because MCP hosts sometimes remember "always allow this tool" and that's dangerous for `factory_reset`, `erase_and_flash`, `uhubctl_power(action='off')`, and `uhubctl_cycle`.
 
-**TCP / native-host nodes.** Setting `MESHTASTIC_MCP_TCP_HOST=<host[:port]>` makes `list_devices` surface a `meshtasticd` daemon (e.g. the `native-macos` build) as a synthetic `tcp://host:port` entry, and `connect()` routes through `meshtastic.tcp_interface.TCPInterface` instead of `SerialInterface`. Every read/write/admin tool that flows through `connect()` works against the daemon transparently. USB-only tools (`pio_flash`, `erase_and_flash`, `update_flash`, `touch_1200bps`, `serial_open`, `esptool_*`, `nrfutil_*`, `picotool_*`) raise a clear `ConnectionError` when handed a `tcp://` port; `pio_flash` against a `native*` env raises a `FlashError` (no upload step - use `build` and run the binary directly). The pytest harness still assumes USB-attached devices per role; TCP-aware fixtures are deferred. See the meshtastic-mcp repo's README § "TCP / native-host nodes".
+**TCP / native-host nodes.** Setting `MESHTASTIC_MCP_TCP_HOST=<host[:port]>` makes `list_devices` surface a `meshtasticd` daemon (e.g. the `native-macos` build) as a synthetic `tcp://host:port` entry, and `connect()` routes through `meshtastic.tcp_interface.TCPInterface` instead of `SerialInterface`. Every read/write/admin tool that flows through `connect()` works against the daemon transparently. USB-only tools (`pio_flash`, `erase_and_flash`, `update_flash`, `touch_1200bps`, `serial_open`, `esptool_*`, `nrfutil_*`, `picotool_*`) raise a clear `ConnectionError` when handed a `tcp://` port; `pio_flash` against a `native*` env raises a `FlashError` (no upload step — use `build` and run the binary directly). The pytest harness still assumes USB-attached devices per role; TCP-aware fixtures are deferred. See `mcp-server/README.md` § "TCP / native-host nodes".
 
-### Frame injection: testing the off-air receive path
-
-The `toRadio` API can only inject **locally-originated** traffic - the firmware forces `p.from = 0` in `MeshService::handleToRadio`, which bypasses the `from != 0` receive path and everything gated on it (remote admin authorization, the admin session-passkey check, hop handling, promiscuous sniffing). To exercise those paths you either need a second transmitting radio, or **frame injection**: a build-flagged seam that delivers a client-supplied frame into the real RX pipeline as if it arrived off the LoRa chip.
-
-- **Firmware:** build with `-D MESHTASTIC_ENABLE_FRAME_INJECTION=1` (`src/configuration.h`, off by default - it forges over-the-air traffic and must never ship enabled). `MeshService::injectAsReceived` extends the existing portduino `SimRadio` `SIMULATOR_APP` path to real hardware: it unwraps a `Compressed` envelope (`portnum == UNKNOWN_APP` → verbatim ciphertext the router decrypts; else → decoded payload for that portnum), then calls `router->enqueueReceivedMessage()` - the exact entry point `RadioLibInterface::handleReceiveInterrupt` uses. Injection is reached before the `p.from = 0` line, so a forged sender survives; `from == 0` is dropped to match real RX.
-- **Host:** drive it with the meshtastic-mcp `inject_frame` tool (or `cli/meshinject.py`). The crafter replicates channel crypto (default-PSK expansion, `xorHash` channel hash, AES-CTR with the `packetId|from|0` nonce), so an encrypted frame decrypts on-device as if received. Modes: `text`, `raw`, `admin` (+ `pki`/`public_key` for the PKC-admin path), `ciphertext`, `fuzz` (malformed-frame decode-path/crash testing).
-- **Example - remote-admin session-key repro:** set the target's `admin_key[0]` to a key you hold, then inject an `admin` set_owner with `pki=true`, that key, and a stale `session_hex`. The node logs `PKC admin payload with authorized sender key` → `Expected session key: 00…` → `Admin message without session_key!` - the exact ndoo scenario, on real silicon. Capture logs via `set_debug_log_api` on the same connection.
-- **nRF52 gotcha:** the USB CDC wedges under rapid `SerialInterface` open/close churn (unrelated to injection) - keep setup + inject + log-capture on one connection; recover a hung board via a 1200 bps-touch DFU reflash.
-
-### Hardware test suite (`run-tests.sh`, from a meshtastic-mcp checkout)
+### Hardware test suite (`mcp-server/run-tests.sh`)
 
 The wrapper auto-detects connected devices (VID → role map: `0x239A` → `nrf52`, `0x303A`/`0x10C4` → `esp32s3`), maps each role to a PlatformIO env (`nrf52` → `rak4631`, `esp32s3` → `heltec-v3`, overridable via `MESHTASTIC_MCP_ENV_<ROLE>`), then invokes pytest. Zero pre-flight config needed from the operator.
 
 Suite tiers (collected + run in this order via `pytest_collection_modifyitems`):
 
-1. `tests/unit/` - pure Python (boards parse, pio wrapper, userPrefs parse, testing profile, uhubctl parser). No hardware.
-2. `tests/test_00_bake.py` - flashes each detected device with current `userPrefs.jsonc` merged with the session's test profile. Has its own skip-if-already-baked check comparing region + primary channel to the session profile; skips cheaply on warm devices.
-3. `tests/mesh/` - multi-device mesh: bidirectional send, broadcast delivery, direct-with-ACK, mesh formation within 60s. Parametrized `[nrf52->esp32s3]` and `[esp32s3->nrf52]`. Includes `test_peer_offline_recovery` which uses uhubctl to physically power off one peer mid-conversation (requires uhubctl; skips without).
-4. `tests/telemetry/` - `DEVICE_METRICS_APP` broadcast timing.
-5. `tests/monitor/` - boot-log panic check.
-6. `tests/recovery/` - `uhubctl` power-cycle round-trip + NVS persistence across hard reset. Requires `uhubctl` installed and a PPPS-capable hub; entire tier auto-skips otherwise.
-7. `tests/ui/` - input-broker-driven screen navigation with camera + OCR evidence.
-8. `tests/fleet/` - PSK seed session isolation.
-9. `tests/admin/` - channel URL roundtrip, owner persistence across reboot.
-10. `tests/provisioning/` - region + modem + slot bake, admin key presence, `UNSET` region blocks TX, userPrefs survive factory reset.
+1. `tests/unit/` — pure Python (boards parse, pio wrapper, userPrefs parse, testing profile, uhubctl parser). No hardware.
+2. `tests/test_00_bake.py` — flashes each detected device with current `userPrefs.jsonc` merged with the session's test profile. Has its own skip-if-already-baked check comparing region + primary channel to the session profile; skips cheaply on warm devices.
+3. `tests/mesh/` — multi-device mesh: bidirectional send, broadcast delivery, direct-with-ACK, mesh formation within 60s. Parametrized `[nrf52->esp32s3]` and `[esp32s3->nrf52]`. Includes `test_peer_offline_recovery` which uses uhubctl to physically power off one peer mid-conversation (requires uhubctl; skips without).
+4. `tests/telemetry/` — `DEVICE_METRICS_APP` broadcast timing.
+5. `tests/monitor/` — boot-log panic check.
+6. `tests/recovery/` — `uhubctl` power-cycle round-trip + NVS persistence across hard reset. Requires `uhubctl` installed and a PPPS-capable hub; entire tier auto-skips otherwise.
+7. `tests/ui/` — input-broker-driven screen navigation with camera + OCR evidence.
+8. `tests/fleet/` — PSK seed session isolation.
+9. `tests/admin/` — channel URL roundtrip, owner persistence across reboot.
+10. `tests/provisioning/` — region + modem + slot bake, admin key presence, `UNSET` region blocks TX, userPrefs survive factory reset.
 
 Invocation patterns:
 
 ```bash
-# run from a meshtastic-mcp checkout, with MESHTASTIC_FIRMWARE_ROOT=/path/to/firmware
-./run-tests.sh                                        # full suite (auto-bake-if-needed)
-./run-tests.sh --force-bake                           # reflash before testing
-./run-tests.sh --assume-baked                         # skip bake (caller vouches for device state)
-./run-tests.sh tests/mesh                             # one tier
-./run-tests.sh tests/mesh/test_direct_with_ack.py     # one file
-./run-tests.sh -k telemetry                           # name filter
+./mcp-server/run-tests.sh                                        # full suite (auto-bake-if-needed)
+./mcp-server/run-tests.sh --force-bake                           # reflash before testing
+./mcp-server/run-tests.sh --assume-baked                         # skip bake (caller vouches for device state)
+./mcp-server/run-tests.sh tests/mesh                             # one tier
+./mcp-server/run-tests.sh tests/mesh/test_direct_with_ack.py     # one file
+./mcp-server/run-tests.sh -k telemetry                           # name filter
 ```
 
-**No hardware detected?** The wrapper auto-narrows to `tests/unit/` only and prints `detected hub : (none)` in the pre-flight header. Agents interpreting the output should call this out explicitly - a 52-test green run without hardware is qualitatively different from a 12-unit-test green run.
+**No hardware detected?** The wrapper auto-narrows to `tests/unit/` only and prints `detected hub : (none)` in the pre-flight header. Agents interpreting the output should call this out explicitly — a 52-test green run without hardware is qualitatively different from a 12-unit-test green run.
 
 **Artifacts every run produces:**
 
-- `tests/report.html` - self-contained pytest-html. Each test gets a `Meshtastic debug` section with the tail of firmware log + device state dump. **Open this first** on failures; it's the canonical evidence source.
-- `tests/junit.xml` - CI-parseable.
-- `tests/reportlog.jsonl` - pytest-reportlog stream (`$report_type` keyed JSONL). Consumed by the live TUI.
-- `tests/fwlog.jsonl` - firmware log mirror from the `meshtastic.log.line` pubsub topic. Populated by the `_firmware_log_stream` autouse session fixture.
+- `mcp-server/tests/report.html` — self-contained pytest-html. Each test gets a `Meshtastic debug` section with the tail of firmware log + device state dump. **Open this first** on failures; it's the canonical evidence source.
+- `mcp-server/tests/junit.xml` — CI-parseable.
+- `mcp-server/tests/reportlog.jsonl` — pytest-reportlog stream (`$report_type` keyed JSONL). Consumed by the live TUI.
+- `mcp-server/tests/fwlog.jsonl` — firmware log mirror from the `meshtastic.log.line` pubsub topic. Populated by the `_firmware_log_stream` autouse session fixture.
 
 ### Live TUI (`meshtastic-mcp-test-tui`)
 
@@ -900,7 +634,7 @@ A Textual-based live view that wraps `run-tests.sh`. Tails reportlog for per-tes
 Launch:
 
 ```bash
-# from a meshtastic-mcp checkout (MESHTASTIC_FIRMWARE_ROOT set)
+cd mcp-server
 .venv/bin/meshtastic-mcp-test-tui                 # full suite
 .venv/bin/meshtastic-mcp-test-tui tests/mesh      # args pass through to pytest
 ```
@@ -925,29 +659,29 @@ House rules for agents running these prompts:
 
 ### Key fixtures (test authors + agents debugging)
 
-`tests/conftest.py` (in the meshtastic-mcp checkout) provides:
+`mcp-server/tests/conftest.py` provides:
 
-- **`_session_userprefs`** (autouse session) - snapshots `userPrefs.jsonc` at session start, merges the session test profile via `userprefs.merge_active(test_profile)`, restores at teardown. Four layers of safety: pytest teardown + `atexit` + sidecar file (`userPrefs.jsonc.mcp-session-bak`) + startup self-heal in `run-tests.sh`. **Do not edit `userPrefs.jsonc` from inside a test.**
-- **`_firmware_log_stream`** (autouse session) - subscribes to `meshtastic.log.line` pubsub on every connected `SerialInterface` and mirrors lines to `tests/fwlog.jsonl`. Drives the TUI firmware-log pane.
-- **`_debug_log_buffer`** (autouse per-test) - captures last 200 firmware log lines + device state for attachment to the pytest-html `Meshtastic debug` section on failure.
-- **`hub_devices`** (session) - `dict[role, SerialInterface]` with session-long exclusive port locks. Reason the TUI's device poller is gated to startup + post-run only.
-- **`baked_mesh`** - parametrized mesh-pair fixture; depends on `test_00_bake`. `pytest_generate_tests` in `conftest.py` auto-generates `[nrf52->esp32s3]` and `[esp32s3->nrf52]` variants.
-- **`test_profile`** - session-scoped dict: region, primary channel, admin key, PSK seed. Derived from `MESHTASTIC_MCP_SEED` (defaults to `mcp-<user>-<host>`).
+- **`_session_userprefs`** (autouse session) — snapshots `userPrefs.jsonc` at session start, merges the session test profile via `userprefs.merge_active(test_profile)`, restores at teardown. Four layers of safety: pytest teardown + `atexit` + sidecar file (`userPrefs.jsonc.mcp-session-bak`) + startup self-heal in `run-tests.sh`. **Do not edit `userPrefs.jsonc` from inside a test.**
+- **`_firmware_log_stream`** (autouse session) — subscribes to `meshtastic.log.line` pubsub on every connected `SerialInterface` and mirrors lines to `tests/fwlog.jsonl`. Drives the TUI firmware-log pane.
+- **`_debug_log_buffer`** (autouse per-test) — captures last 200 firmware log lines + device state for attachment to the pytest-html `Meshtastic debug` section on failure.
+- **`hub_devices`** (session) — `dict[role, SerialInterface]` with session-long exclusive port locks. Reason the TUI's device poller is gated to startup + post-run only.
+- **`baked_mesh`** — parametrized mesh-pair fixture; depends on `test_00_bake`. `pytest_generate_tests` in `conftest.py` auto-generates `[nrf52->esp32s3]` and `[esp32s3->nrf52]` variants.
+- **`test_profile`** — session-scoped dict: region, primary channel, admin key, PSK seed. Derived from `MESHTASTIC_MCP_SEED` (defaults to `mcp-<user>-<host>`).
 
 ### Firmware integration points tied to the test harness
 
 Two firmware changes exist specifically so the test harness works reliably. **Keep these in mind when touching related code.**
 
-- **`src/mesh/StreamAPI.cpp` + `StreamAPI.h`** - `emitLogRecord` uses a dedicated `fromRadioScratchLog` + `txBufLog` pair and a `concurrency::Lock streamLock`. Before this fix, `debug_log_api_enabled=true` would tear `FromRadio` protobufs on the serial transport because `emitTxBuffer` and `emitLogRecord` shared a single scratch buffer. The conftest enables the log stream session-wide; without this fix the device would corrupt its own FromRadio replies mid-session.
-- **`src/mesh/PhoneAPI.cpp`** - `ToRadio` `Heartbeat(nonce=1)` triggers `nodeInfoModule->sendOurNodeInfo(NODENUM_BROADCAST, true, 0, true)` for serial clients, mirroring the pre-existing behavior for TCP/UDP clients in `PacketAPI.cpp`. The mesh tests rely on this to force a NodeInfo broadcast right after connect so the peer discovers them before the test's first assertion.
+- **`src/mesh/StreamAPI.cpp` + `StreamAPI.h`** — `emitLogRecord` uses a dedicated `fromRadioScratchLog` + `txBufLog` pair and a `concurrency::Lock streamLock`. Before this fix, `debug_log_api_enabled=true` would tear `FromRadio` protobufs on the serial transport because `emitTxBuffer` and `emitLogRecord` shared a single scratch buffer. The conftest enables the log stream session-wide; without this fix the device would corrupt its own FromRadio replies mid-session.
+- **`src/mesh/PhoneAPI.cpp`** — `ToRadio` `Heartbeat(nonce=1)` triggers `nodeInfoModule->sendOurNodeInfo(NODENUM_BROADCAST, true, 0, true)` for serial clients, mirroring the pre-existing behavior for TCP/UDP clients in `PacketAPI.cpp`. The mesh tests rely on this to force a NodeInfo broadcast right after connect so the peer discovers them before the test's first assertion.
 
-If you're modifying `StreamAPI`, `PhoneAPI`, `NodeInfoModule`, or `userPrefs` flow, run `./run-tests.sh` (from a meshtastic-mcp checkout, with `MESHTASTIC_FIRMWARE_ROOT` pointed here) at minimum before asking for review.
+If you're modifying `StreamAPI`, `PhoneAPI`, `NodeInfoModule`, or `userPrefs` flow, run `./mcp-server/run-tests.sh` at minimum before asking for review.
 
 ### Recovery playbooks
 
 | Symptom                                                                           | First check                                                   | Fix                                                                                                                                                                                                                              |
 | --------------------------------------------------------------------------------- | ------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `userPrefs.jsonc` dirty after test run                                            | `git status --porcelain userPrefs.jsonc`                      | If non-empty, re-run `./run-tests.sh` (from a meshtastic-mcp checkout) once - the pre-flight self-heal restores from sidecar. If still dirty, `git checkout userPrefs.jsonc`.                                                    |
+| `userPrefs.jsonc` dirty after test run                                            | `git status --porcelain userPrefs.jsonc`                      | If non-empty, re-run `./mcp-server/run-tests.sh` once — the pre-flight self-heal restores from sidecar. If still dirty, `git checkout userPrefs.jsonc`.                                                                          |
 | Port busy / wedged CP2102 on macOS                                                | `lsof /dev/cu.usbserial-0001`                                 | Kill the holder. USB replug if the kernel still reports busy. Often a stale `pio device monitor` or zombie `meshtastic_mcp` process.                                                                                             |
 | nRF52 appears unresponsive                                                        | `list_devices` shows VID `0x239A` but `device_info` times out | `touch_1200bps(port=...)` drops it into the DFU bootloader → `pio_flash` re-installs.                                                                                                                                            |
 | Device fully wedged (Guru Meditation, frozen CDC, no DFU)                         | `list_devices` shows the VID but every admin call times out   | `uhubctl_cycle(role="nrf52", confirm=True)` hard-power-cycles the port via USB hub PPPS. `baked_single`'s auto-recovery hook does this once automatically if uhubctl is installed. Falls back to physical replug if no PPPS hub. |
@@ -957,17 +691,17 @@ If you're modifying `StreamAPI`, `PhoneAPI`, `NodeInfoModule`, or `userPrefs` fl
 | Entire `tests/recovery/` tier skipped                                             | `command -v uhubctl`                                          | Expected if `uhubctl` isn't on PATH. Install via `brew install uhubctl` (macOS) or `apt install uhubctl` (Debian/Ubuntu). Also skips if no hub advertises PPPS.                                                                  |
 | Entire `tests/ui/` tier skipped ("firmware not baked with USERPREFS_UI_TEST_LOG") | reportlog.jsonl for the skip reason                           | Re-run with `--force-bake` so the UI-log macro gets compiled into the fresh firmware. First run after the Round-3 landing always re-bakes.                                                                                       |
 | `tests/ui/` runs but captures are all 1×1 black PNGs                              | `MESHTASTIC_UI_CAMERA_DEVICE_ESP32S3`                         | Env var not set → `NullBackend`. Point a USB webcam at the heltec-v3 OLED and set the device index; `.venv/bin/python -c "import cv2; [print(i, cv2.VideoCapture(i).read()[0]) for i in range(5)]"` discovers it.                |
-| Tests fail only on first attempt then pass on rerun                               | -                                                             | State leak from a prior session. Run with `--force-bake` to reset to a known state.                                                                                                                                              |
+| Tests fail only on first attempt then pass on rerun                               | —                                                             | State leak from a prior session. Run with `--force-bake` to reset to a known state.                                                                                                                                              |
 
 ### Never do these without asking
 
-- `factory_reset` - wipes node identity; regenerates PKI keypair. Mesh peers will reject old DMs until re-exchange. Legitimate only when the operator explicitly wants it.
-- `erase_and_flash` - full chip erase; destroys all on-device state.
-- `esptool_erase_flash` / `esptool_raw` write/erase - bypasses pio's safety chain.
-- `set_config` on `lora.region` - changes regulatory domain; requires physical-location context the operator has and the agent doesn't.
-- `reboot` / `shutdown` mid-test - breaks fixture invariants.
+- `factory_reset` — wipes node identity; regenerates PKI keypair. Mesh peers will reject old DMs until re-exchange. Legitimate only when the operator explicitly wants it.
+- `erase_and_flash` — full chip erase; destroys all on-device state.
+- `esptool_erase_flash` / `esptool_raw` write/erase — bypasses pio's safety chain.
+- `set_config` on `lora.region` — changes regulatory domain; requires physical-location context the operator has and the agent doesn't.
+- `reboot` / `shutdown` mid-test — breaks fixture invariants.
 - `push -f`, `rebase -i`, `reset --hard`, or any history-rewriting git operation.
-- Clicking computer-use tools on web links in Mail/Messages/PDFs - open URLs via the claude-in-chrome MCP so the extension's link-safety checks apply.
+- Clicking computer-use tools on web links in Mail/Messages/PDFs — open URLs via the claude-in-chrome MCP so the extension's link-safety checks apply.
 
 ## Resources
 

.github/millis-deadline-allowlist.txt

@@ -1,22 +0,0 @@
-# Allowlist for the millis-deadline-check guard in .github/workflows/test_native.yml.
-#
-# That guard rejects comparisons made directly against millis(), because they invert while the
-# deadline sits on the far side of the 32-bit wrap. Use Throttle::deadlinePassed(deadline) or
-# Throttle::hasElapsed(lastEvent, intervalMs) instead - see .github/copilot-instructions.md.
-#
-# Only add a line here when the comparison genuinely is not a deadline test. The usual valid case is
-# an *uptime threshold*: "has the device been up for at least N ms", where there is no stored
-# deadline and no event to measure from. Those still misbehave briefly after a wrap - the threshold
-# is simply re-crossed - which is harmless for boot-holdoff logic and not worth new state.
-#
-# Format: <path><TAB><exact trimmed source line, comments stripped>
-# Line numbers are deliberately absent so edits above an entry do not invalidate it. A `#` comment
-# on the code line is stripped before matching, so do not include one here.
-
-# Boot holdoff, not a deadline: suppresses a phantom shutdown from floating pins during the first
-# 30s of uptime. Pairs with the buttonPressStartTime > 30000 test on the same line.
-src/input/ButtonThread.cpp	if (millis() > 30000 && buttonPressStartTime > 30000 && _longLongPress != INPUT_BROKER_NONE &&
-
-# Boot-window check, not a deadline: draws the custom OEM logo only during the first 10s of uptime,
-# so the ordinary Meshtastic logo is used at shutdown.
-src/graphics/niche/InkHUD/Applets/System/Logo/LogoApplet.cpp	if (millis() < 10 * 1000UL) {

.github/node-id-format-allowlist.txt

@@ -1,15 +0,0 @@
-# Exception list for bin/lint-node-id-format.sh (trunk linter: node-id-format).
-#
-# Format:  <path>[:<line>]   <reason>
-#   - "<path>"          exempts the whole file
-#   - "<path>:<line>"   exempts one call site
-#   - blank lines and # comments are ignored; the reason column is mandatory
-#
-# Intentionally empty. The known pre-existing sites - PacketHistory.cpp, NodeInfoModule.cpp
-# and PositionModule.cpp - are deliberately NOT listed, so trunk surfaces them the next time
-# someone edits those files and they get cleaned up in the change that was already touching
-# them. The rule emits "note", trunk's only non-blocking level, so this costs a notice rather
-# than a red PR.
-#
-# Add an entry only for a value the linter has misread as an ID - a CRC, a register, a hash -
-# and say which, so the next reader can tell a real exemption from a deferred cleanup.

.github/prompts/mcp-diagnose.prompt.md

@@ -0,0 +1,64 @@
+---
+mode: agent
+description: Device health report via the meshtastic MCP tools (Copilot equivalent of the Claude Code /diagnose slash command)
+---
+
+# `/mcp-diagnose` — device health report
+
+Equivalent of `.claude/commands/diagnose.md`. Use when the operator asks to "check the devices", "what's the mesh looking like", "is nrf52 alive", etc.
+
+This prompt assumes the meshtastic MCP server is registered with your VS Code Copilot agent. If it isn't, fall back to running `./mcp-server/run-tests.sh tests/unit` plus a short `device_info` script via the terminal.
+
+## What to do
+
+1. **Enumerate hardware** via the `list_devices` MCP tool (with `include_unknown=True`). For each entry where `likely_meshtastic=True`, capture `port`, `vid`, `pid`, `description`.
+
+2. **Apply the operator's filter** (if any):
+   - No filter → every likely-meshtastic device.
+   - `nrf52` → `vid == 0x239a`
+   - `esp32s3` → `vid == 0x303a` or `vid == 0x10c4`
+   - A `/dev/cu.*` path → only that port.
+   - Anything else → substring match on port.
+
+3. **For each selected device, in sequence (don't parallelize — SerialInterface holds an exclusive port lock):**
+   - `device_info(port=<p>)` → `my_node_num`, `long_name`, `short_name`, `firmware_version`, `hw_model`, `region`, `num_nodes`, `primary_channel`
+   - `list_nodes(port=<p>)` → peer count, which peers have `publicKey`, SNR/RSSI distribution
+   - `get_config(section="lora", port=<p>)` → region, preset, channel_num, tx_power, hop_limit
+   - If anything looks off (can't connect, `num_nodes` wrong, missing `firmware_version`), open a short firmware-log window: `serial_open(port=<p>, env=<inferred>)`, wait 3 seconds, `serial_read(session_id, max_lines=100)`, `serial_close(session_id)`. Infer env from VID (0x239a → `rak4631`, 0x303a/0x10c4 → `heltec-v3`) unless an `MESHTASTIC_MCP_ENV_<ROLE>` env var overrides it.
+
+4. **Hub health** (call once, not per-device): `uhubctl_list()` — enumerates every USB hub the host sees. Cross-reference each Meshtastic device's VID to find which hub + port it's on. Flag in the report if:
+   - No hub advertises `ppps=true` → `tests/recovery/` can't run; hard-recovery via `uhubctl_cycle` isn't available.
+   - A Meshtastic device is on a non-PPPS hub → note it; moving to a PPPS hub unlocks auto-recovery.
+   - `uhubctl_list` raises `ConfigError: uhubctl not found` → report as "uhubctl not installed"; don't treat as a device fault.
+
+5. **Render per-device report** as a compact block:
+
+   ```text
+   [nrf52 @ /dev/cu.usbmodem1101]      fw=2.7.23.bce2825, hw=RAK4631
+     owner       : Meshtastic 40eb / 40eb
+     region/band : US, channel 88, LONG_FAST
+     tx_power    : 30 dBm, hop_limit=3
+     peers       : 1 (esp32s3 0x433c2428, pubkey ✓, SNR 6.0 / RSSI -24 dBm)
+     primary ch  : McpTest
+     hub         : 1-1.3 port 2 (PPPS, uhubctl-controllable)
+     firmware    : no panics in last 3s
+   ```
+
+   Flag abnormalities inline with `⚠︎ <short reason>` — missing pubkey on a known peer, region UNSET, mismatched channel name, device on non-PPPS hub, etc.
+
+6. **Cross-device correlation** (when >1 device selected):
+   - Do both see each other in `nodesByNum`?
+   - Do `region`, `channel_num`, `modem_preset` match across devices?
+   - Do the primary channel names match? (Different name → different PSK → no decode.)
+
+7. **Suggest next steps only for recognizable failure modes**, never speculatively:
+   - Stale PKI one-way → "`/mcp-test tests/mesh/test_direct_with_ack.py` — the test's retry+nodeinfo-ping heals this."
+   - Region mismatch → "re-bake one side via `./mcp-server/run-tests.sh --force-bake`."
+   - Device unreachable, DFU reachable → `touch_1200bps(port=...)` + `pio_flash`. If not even DFU responds and the device is on a PPPS hub, escalate to `uhubctl_cycle(role=..., confirm=True)`.
+   - CP2102-wedged-driver on macOS → see `run-tests.sh` notes.
+
+## Hard constraints
+
+- **Read-only.** No `set_config`, no `reboot`, no `factory_reset`, no `flash`. If the operator wants mutation, they'll escalate explicitly.
+- **Open/query/close per device.** Never hold multiple SerialInterfaces to the same port. The port lock is exclusive.
+- **Don't infer env beyond the VID map** — if the operator has an unusual board, ask them which env to use rather than guessing.

.github/prompts/mcp-repro.prompt.md

@@ -0,0 +1,68 @@
+---
+mode: agent
+description: Re-run a specific test N times to triage flakes; diff firmware logs between passes and failures (Copilot equivalent of the Claude Code /repro slash command)
+---
+
+# `/mcp-repro` — flakiness triage for one test
+
+Equivalent of `.claude/commands/repro.md`. Use when the operator says "that one test is flaky — dig in", "repro the direct_with_ack failure", "why does X sometimes fail?".
+
+## What to do
+
+1. **Parse the operator's input** into two pieces:
+   - **Test identifier** — either a pytest node id (has `::` or starts with `tests/`) or a `-k`-style filter (plain substring like `direct_with_ack`).
+   - **Count** — integer, default `5`, cap at `20`. If the operator asks for 50, negotiate down and explain (airtime + USB wear).
+
+2. **Sanity-check the hub** via the `list_devices` MCP tool. If the test name references `nrf52` or `esp32s3` and the matching VID isn't present, stop and report — re-running won't help.
+
+3. **Loop** N times. Each iteration:
+
+   ```bash
+   ./mcp-server/run-tests.sh <test-id> --tb=short -p no:cacheprovider
+   ```
+
+   `-p no:cacheprovider` keeps pytest from caching anything between iterations. Capture: exit code, duration, and (on failure) the `Meshtastic debug` firmware-log section from `mcp-server/tests/report.html`.
+
+4. **Tally** results as you go:
+
+   ```text
+   attempt 1: PASS (42s)
+   attempt 2: FAIL (128s)    ← fw log captured
+   attempt 3: PASS (39s)
+   attempt 4: FAIL (121s)
+   attempt 5: PASS (41s)
+   --------------------------------------------------
+   pass rate: 3/5 (60%)  |  mean duration: 74s
+   ```
+
+5. **On mixed outcomes, diff the firmware logs** between one representative pass and one representative fail. Focus on:
+   - Error-level lines present only in failures (`PKI_UNKNOWN_PUBKEY`, `Alloc an err=`, `Skip send`, `No suitable channel`, `NAK`)
+   - Timing around the assertion point (broadcast sent? ACK received? retry fired?)
+   - Device-state fields that changed between attempts
+
+   Surface the top 3 differences as a compact "passes when / fails when" table with uptime timestamps. Don't dump full logs.
+
+6. **Classify** the flake into one of:
+   - **LoRa airtime collision** — pass rate improves with fewer concurrent transmitters. Suggest a `time.sleep` gap or retry bump in the test body.
+   - **PKI key staleness** — first attempt fails, subsequent ones pass; existing retry-loop pattern in `test_direct_with_ack.py` is the fix.
+   - **NodeInfo cooldown** — `Skip send NodeInfo since we sent it <600s ago` in fail-only logs; needs a `broadcast_nodeinfo_ping()` warmup.
+   - **Hardware-specific** — one direction consistently fails, firmware versions differ, CP2102 driver wedged, etc. For a device wedged past `touch_1200bps`, recommend `uhubctl_cycle(role=..., confirm=True)` to hard-power-cycle its hub port (requires `uhubctl` installed).
+   - **Device went dark mid-run** — fails from some iteration onward and never recovers; firmware log stops arriving. Almost always a Guru crash with frozen CDC. Recommend `uhubctl_cycle` before the next iteration; escalate to replug if that also fails.
+   - **Unknown** — say so. Don't invent a root cause.
+
+7. **Report back** with:
+   - Pass rate + mean duration.
+   - Classification + the specific log evidence for it.
+   - A concrete next step (tighter assertion, more retries, open `/mcp-diagnose`, file a bug, nothing).
+
+## Examples
+
+- `tests/mesh/test_direct_with_ack.py::test_direct_with_ack_roundtrip[esp32s3->nrf52] 10` — 10 runs of that parametrized case.
+- `broadcast_delivers` — no `::`, no `tests/`; treat as `-k broadcast_delivers`; runs every match 5 times.
+- `tests/telemetry/test_device_telemetry_broadcast.py 3` — shorter count for a slow test.
+
+## Notes
+
+- If the FIRST attempt fails and the rest pass, that's a state-leak signature — suggest starting from `--force-bake` or a clean device state rather than chasing the first-failure firmware logs.
+- If ALL N fail, this isn't a flake — it's a regression. Say so, stop iterating, escalate to `/mcp-test` for full-suite context.
+- Don't rebuild firmware during triage. Flakes that only reproduce under different firmware belong in a separate session with a plan.

.github/prompts/mcp-test.prompt.md

@@ -0,0 +1,57 @@
+---
+mode: agent
+description: Run the mcp-server test suite and interpret results (Copilot equivalent of the Claude Code /test slash command)
+---
+
+# `/mcp-test` — mcp-server test runner with interpretation
+
+Equivalent of the Claude Code `/test` slash command in `.claude/commands/test.md`. Use this when the operator asks you to "run the tests", "check the mcp test suite", "run the mesh tests", etc.
+
+## What to do
+
+1. **Invoke the wrapper** from the firmware repo root:
+
+   ```bash
+   ./mcp-server/run-tests.sh [pytest-args]
+   ```
+
+   If the operator specified a subset (e.g. "just the mesh tests"), pass it through as `tests/mesh` or a pytest `-k filter`. If they said nothing, use the wrapper's defaults (full suite with pytest-html report).
+
+   The wrapper auto-detects connected Meshtastic devices, maps each to its PlatformIO env, exports the required env vars, and invokes pytest. Zero pre-flight config needed from the operator.
+
+2. **Read the pre-flight header** (first few lines of wrapper output). The `detected hub :` line lists role → port → env mappings. If it reads `(none)`, the wrapper narrowed to `tests/unit` only — call that out explicitly so the operator knows hardware tiers were skipped.
+
+3. **On pass**: one-line summary like `N passed, M skipped in <duration>`. Don't enumerate test names. DO mention any non-placeholder SKIPs and name the cause:
+   - `"role not present on hub"` → device unplugged; operator should reconnect.
+   - `"firmware not baked with USERPREFS_UI_TEST_LOG"` → tests/ui skipped; the UI-log compile macro isn't in the baked firmware. Suggest `--force-bake`.
+   - `"uhubctl not installed"` → tests/recovery + `test_peer_offline_recovery` skipped. Suggest `brew install uhubctl` / `apt install uhubctl`.
+   - `"no PPPS-capable hubs detected"` → tests/recovery skipped because the attached hub doesn't support per-port power switching; won't run on that setup.
+   - `"opencv-python-headless is not installed"` → tests/ui auto-deselected by `run-tests.sh`. Suggest `pip install -e 'mcp-server/.[ui]'`.
+
+4. **On failure**: open `mcp-server/tests/report.html` (pytest-html output, self-contained) and extract the `Meshtastic debug` section for each failed test. That section includes a firmware log stream (last 200 lines) and device state dump. For each failure, summarise:
+   - test name
+   - one-line assertion message
+   - the specific firmware log lines that explain why (look for `PKI_UNKNOWN_PUBKEY`, `Skip send NodeInfo`, `Error=`, `Guru Meditation`, `assertion failed`, `No suitable channel`)
+   - for UI-tier failures also check `mcp-server/tests/ui_captures/<session>/<test>/transcript.md` (per-step frame + OCR)
+
+5. **Classify each failure** as one of:
+   - **Transient flake** — LoRa collision, first-attempt NAK with self-heal pattern, timing-sensitive assertion. Suggest `/mcp-repro <test-id>` to confirm.
+   - **Environmental** — device unreachable, port busy, CP2102 driver wedged on macOS. Suggest recovery in escalation order: (a) replug USB, (b) `touch_1200bps` + `pio_flash` for nRF52 DFU, (c) `uhubctl_cycle(role=..., confirm=True)` for a device wedged past DFU (needs `uhubctl` installed; `baked_single` does this once automatically when available). Also check `git status userPrefs.jsonc`.
+   - **Regression** — same assertion fails repeatedly on re-runs, firmware log shows novel errors. Identify the firmware module likely responsible.
+
+6. **Do NOT run destructive recovery automatically**. If a failure looks like it needs a reflash, factory*reset, `uhubctl_cycle`, or replug — \_describe the steps* and let the operator decide. Never burn airtime or flash cycles without approval.
+
+## Arguments convention
+
+Operators generally invoke this prompt either with no arguments (full suite) or with a specific subset. Examples:
+
+- `tests/mesh` — one tier
+- `tests/mesh/test_direct_with_ack.py::test_direct_with_ack_roundtrip` — one test
+- `--force-bake` — reflash devices first
+- `-k telemetry` — name-filter
+
+## Side-effects to confirm in your summary
+
+- `userPrefs.jsonc` should be clean after a successful run. The session fixture in `mcp-server/tests/conftest.py` (`_session_userprefs`) snapshots and restores. Check `git status --porcelain userPrefs.jsonc` and report if it's non-empty.
+- `mcp-server/tests/report.html` and `junit.xml` regenerate on every run.
+- The wrapper prints a warning if a `.mcp-session-bak` sidecar was left over from a crashed prior session and auto-restores from it — mention that if it happened.

.github/prompts/new-module.prompt.md

@@ -6,9 +6,9 @@ Guide for developing a new Meshtastic firmware module.
 
 Choose the appropriate base class:
 
-1. **`MeshModule`** - Raw base class. Override `wantPacket()` and `handleReceived()`. Returns `ProcessMessage::STOP` or `ProcessMessage::CONTINUE`.
-2. **`SinglePortModule`** - Handles a single `meshtastic_PortNum`. Constructor takes `(name, portNum)`. Simplified `wantPacket()` checking `decoded.portnum`. Use `allocDataPacket()` to create outgoing packets.
-3. **`ProtobufModule<T>`** - Template for protobuf-encoded modules. Constructor takes `(name, portNum, fields)`. Override `handleReceivedProtobuf()`. Use `allocDataProtobuf(payload)` to create outgoing packets.
+1. **`MeshModule`** — Raw base class. Override `wantPacket()` and `handleReceived()`. Returns `ProcessMessage::STOP` or `ProcessMessage::CONTINUE`.
+2. **`SinglePortModule`** — Handles a single `meshtastic_PortNum`. Constructor takes `(name, portNum)`. Simplified `wantPacket()` checking `decoded.portnum`. Use `allocDataPacket()` to create outgoing packets.
+3. **`ProtobufModule<T>`** — Template for protobuf-encoded modules. Constructor takes `(name, portNum, fields)`. Override `handleReceivedProtobuf()`. Use `allocDataProtobuf(payload)` to create outgoing packets.
 
 Most modules also mix in `concurrency::OSThread` for periodic background tasks.
 
@@ -32,7 +32,7 @@ class MyModule : public ProtobufModule<meshtastic_MyMessage>, private concurrenc
     // Generate response packet (optional)
     virtual meshtastic_MeshPacket *allocReply() override;
 
-    // Periodic task - return next run interval in ms, or disable()
+    // Periodic task — return next run interval in ms, or disable()
     virtual int32_t runOnce() override;
 
     // Modify packet in-flight before delivery (optional)

.github/prompts/new-sensor.prompt.md

@@ -6,10 +6,10 @@ Guide for adding a new I2C telemetry sensor driver to Meshtastic firmware.
 
 Telemetry sensors live in `src/modules/Telemetry/Sensor/`. There are 50+ existing drivers organized by measurement type. Each sensor integrates with one of the telemetry modules:
 
-- **EnvironmentTelemetryModule** - Temperature, humidity, pressure, gas, light
-- **AirQualityTelemetryModule** - Particulate matter, VOCs
-- **PowerTelemetryModule** - Voltage, current, power monitoring
-- **HealthTelemetryModule** - Heart rate, SpO2, body temperature
+- **EnvironmentTelemetryModule** — Temperature, humidity, pressure, gas, light
+- **AirQualityTelemetryModule** — Particulate matter, VOCs
+- **PowerTelemetryModule** — Voltage, current, power monitoring
+- **HealthTelemetryModule** — Heart rate, SpO2, body temperature
 
 ## Sensor Driver Pattern
 
@@ -75,10 +75,10 @@ The scan runs at boot and populates a device map that telemetry modules use to d
 If the sensor provides data not covered by existing telemetry fields:
 
 1. Add fields to the appropriate message in `protobufs/meshtastic/telemetry.proto`:
-   - `EnvironmentMetrics` - Environmental measurements
-   - `AirQualityMetrics` - Air quality data
-   - `PowerMetrics` - Power/energy data
-   - `HealthMetrics` - Health/biometric data
+   - `EnvironmentMetrics` — Environmental measurements
+   - `AirQualityMetrics` — Air quality data
+   - `PowerMetrics` — Power/energy data
+   - `HealthMetrics` — Health/biometric data
 2. Add a `.options` constraint if needed (field sizes for nanopb)
 3. Regenerate: `bin/regen-protos.sh`
 

.github/prompts/new-variant.prompt.md

@@ -20,14 +20,14 @@ variants/
 
 Each variant needs at minimum:
 
-- `variant.h` - Pin definitions and hardware capabilities
-- `platformio.ini` - Build configuration
+- `variant.h` — Pin definitions and hardware capabilities
+- `platformio.ini` — Build configuration
 
 Optional files:
 
-- `pins_arduino.h` - Arduino pin mapping overrides
-- `rfswitch.h` - RF switch control for multi-band radios
-- `nicheGraphics.h` - InkHUD e-ink configuration
+- `pins_arduino.h` — Arduino pin mapping overrides
+- `rfswitch.h` — RF switch control for multi-band radios
+- `nicheGraphics.h` — InkHUD e-ink configuration
 
 ## variant.h Template
 
@@ -101,25 +101,25 @@ upload_speed = 921600
 
 ### Common Base Configs
 
-- `esp32_base` / `esp32-common.ini` - ESP32
-- `esp32s3_base` - ESP32-S3
-- `esp32c3_base` - ESP32-C3
-- `esp32c6_base` - ESP32-C6
-- `nrf52840_base` / `nrf52.ini` - nRF52840
-- `rp2040_base` - RP2040/RP2350
+- `esp32_base` / `esp32-common.ini` — ESP32
+- `esp32s3_base` — ESP32-S3
+- `esp32c3_base` — ESP32-C3
+- `esp32c6_base` — ESP32-C6
+- `nrf52840_base` / `nrf52.ini` — nRF52840
+- `rp2040_base` — RP2040/RP2350
 
 ### Support Levels
 
-- `custom_meshtastic_support_level = 1` - Built on every PR (actively supported)
-- `custom_meshtastic_support_level = 2` - Built only on merge to main branches
-- `board_level = extra` - Only built on full releases
+- `custom_meshtastic_support_level = 1` — Built on every PR (actively supported)
+- `custom_meshtastic_support_level = 2` — Built only on merge to main branches
+- `board_level = extra` — Only built on full releases
 
 ## Build Manifest Metadata
 
 `bin/platformio-custom.py` emits UI capability flags in the build manifest:
 
-- `custom_meshtastic_has_mui = true/false` - Override MUI detection
-- `custom_meshtastic_has_ink_hud = true/false` - Override InkHUD detection
+- `custom_meshtastic_has_mui = true/false` — Override MUI detection
+- `custom_meshtastic_has_ink_hud = true/false` — Override InkHUD detection
 - Architecture names are normalized (e.g., `esp32s3` → `esp32-s3`)
 
 ## InkHUD E-Ink Variants
@@ -127,7 +127,7 @@ upload_speed = 921600
 For e-ink display variants using the InkHUD framework, add `nicheGraphics.h`:
 
 ```cpp
-// nicheGraphics.h - InkHUD configuration for this variant
+// nicheGraphics.h — InkHUD configuration for this variant
 #define INKHUD                     // Enable InkHUD
 // Configure display, applets, and refresh behavior per device
 ```

.github/workflows/build_debian_src.yml

@@ -21,13 +21,9 @@ permissions:
 jobs:
   build-debian-src:
     runs-on: ubuntu-24.04
-    # Only pushes to the default branch (develop) populate the cache; PR / merge_group runs
-    # restore it but never save, so they stop filling up the repo's Actions cache storage.
-    env:
-      SAVE_CACHE: ${{ github.event_name == 'push' && github.ref_name == github.event.repository.default_branch }}
     steps:
       - name: Checkout code
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           submodules: recursive
           path: meshtasticd
@@ -62,14 +58,6 @@ jobs:
           BUILD_LOCATION: ${{ inputs.build_location }}
         id: version
 
-      - name: Restore PlatformIO cache
-        id: pio-cache
-        uses: actions/cache/restore@v6
-        with:
-          path: meshtasticd/pio/core/.cache
-          key: |
-            pio-deb-src-${{ hashFiles('meshtasticd/platformio.ini', 'meshtasticd/variants/native/portduino.ini', 'meshtasticd/variants/native/portduino/platformio.ini') }}
-
       - name: Fetch libdeps, package debian source
         working-directory: meshtasticd
         run: debian/ci_pack_sdeb.sh
@@ -78,18 +66,6 @@ jobs:
           GPG_KEY_ID: ${{ steps.gpg.outputs.keyid || '' }}
           PKG_VERSION: ${{ steps.version.outputs.deb }}
 
-      - name: Extract cache from pio.tar
-        if: env.SAVE_CACHE == 'true' && steps.pio-cache.outputs.cache-hit != 'true'
-        run: tar -C meshtasticd -xf meshtasticd/pio.tar pio/core/.cache
-
-      - name: Save PlatformIO cache
-        if: env.SAVE_CACHE == 'true' && steps.pio-cache.outputs.cache-hit != 'true'
-        uses: actions/cache/save@v6
-        with:
-          path: meshtasticd/pio/core/.cache
-          key: |
-            pio-deb-src-${{ hashFiles('meshtasticd/platformio.ini', 'meshtasticd/variants/native/portduino.ini', 'meshtasticd/variants/native/portduino/platformio.ini') }}
-
       - name: Store binaries as an artifact
         uses: actions/upload-artifact@v7
         with:

.github/workflows/build_firmware.yml

@@ -23,7 +23,7 @@ jobs:
     outputs:
       artifact-id: ${{ steps.upload-firmware.outputs.artifact-id }}
     steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v6
         with:
           submodules: recursive
 

.github/workflows/build_macos_bin.yml

@@ -14,71 +14,30 @@ permissions:
 jobs:
   build-MacOS:
     runs-on: macos-${{ inputs.macos_ver }}
-    # Only pushes to the default branch (develop) populate the cache; PR / merge_group runs
-    # restore it but never save, so they stop filling up the repo's Actions cache storage.
-    env:
-      SAVE_CACHE: ${{ github.event_name == 'push' && github.ref_name == github.event.repository.default_branch }}
     steps:
       - name: Checkout code
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           submodules: recursive
 
-      - name: Capture runner image version (for caching)
-        id: r_image
-        run: echo "ver=$ImageVersion" >> "$GITHUB_OUTPUT"
-
-      - name: Restore Homebrew cache
-        id: brew-cache
-        uses: actions/cache/restore@v6
-        with:
-          path: ~/Library/Caches/Homebrew
-          key: brew-macos-${{ inputs.macos_ver }}-${{ steps.r_image.outputs.ver }}
-
-      - name: Install deps (Homebrew)
+      - name: Install deps
         shell: bash
-        env:
-          # GitHub-Hosted MacOS runner images are updated frequently
-          # so skip running `brew update` to avoid unnecessary failures and delays.
-          HOMEBREW_NO_AUTO_UPDATE: "1"
-          HOMEBREW_NO_INSTALL_CLEANUP: "1"
-        run: >
-          brew install
-          platformio yaml-cpp libuv openssl@3 libusb argp-standalone pkg-config ulfius jsoncpp
-
-      - name: Save Homebrew cache
-        if: env.SAVE_CACHE == 'true' && steps.brew-cache.outputs.cache-hit != 'true'
-        uses: actions/cache/save@v6
-        with:
-          path: ~/Library/Caches/Homebrew
-          key: brew-macos-${{ inputs.macos_ver }}-${{ steps.r_image.outputs.ver }}
+        run: |
+          brew update
+          brew install platformio yaml-cpp libuv openssl@3 libusb argp-standalone pkg-config ulfius
 
       - name: Get release version string
         run: |
           echo "long=$(./bin/buildinfo.py long)" >> $GITHUB_OUTPUT
         id: version
 
-      - name: Restore PlatformIO cache
-        id: pio-cache
-        uses: actions/cache/restore@v6
-        with:
-          path: ~/.platformio/.cache
-          key: pio-macos-${{ inputs.macos_ver }}-${{ hashFiles('platformio.ini', 'variants/native/portduino.ini', 'variants/native/portduino/platformio.ini') }}
-          restore-keys: |
-            pio-macos-${{ inputs.macos_ver }}-
-
       - name: Build for MacOS
         run: |
           platformio run -e native-macos
         env:
           PKG_VERSION: ${{ steps.version.outputs.long }}
-
-      - name: Save PlatformIO cache
-        if: env.SAVE_CACHE == 'true' && steps.pio-cache.outputs.cache-hit != 'true'
-        uses: actions/cache/save@v6
-        with:
-          path: ~/.platformio/.cache
-          key: pio-macos-${{ inputs.macos_ver }}-${{ hashFiles('platformio.ini', 'variants/native/portduino.ini', 'variants/native/portduino/platformio.ini') }}
+        # Errors in this step should not fail the entire workflow while MacOS support is in development.
+        continue-on-error: true
 
       - name: List output files
         run: ls -lah .pio/build/native-macos/

.github/workflows/build_one_target.yml

@@ -4,14 +4,9 @@ on:
   workflow_dispatch:
     inputs:
       # trunk-ignore(checkov/CKV_GHA_7)
-      target:
-        type: string
-        required: false
-        description: Choose the target board, e.g. nrf52_promicro_diy_tcxo. If blank, will find available targets.
       arch:
         type: choice
         options:
-          - all
           - esp32
           - esp32s3
           - esp32c3
@@ -20,21 +15,35 @@ on:
           - rp2040
           - rp2350
           - stm32
-        description: Choose an arch to limit the search, or 'all' to search all architectures.
-        default: all
+      target:
+        type: string
+        required: false
+        description: Choose the target board, e.g. nrf52_promicro_diy_tcxo. If blank, will find available targets.
+      # find-target:
+      #   type: boolean
+      #   default: true
+      #   description: 'Find the available targets'
 
 permissions: read-all
 
 jobs:
   find-targets:
+    if: ${{ inputs.target == '' }}
     strategy:
       fail-fast: false
       matrix:
         arch:
-          - all
+          - esp32
+          - esp32s3
+          - esp32c3
+          - esp32c6
+          - nrf52840
+          - rp2040
+          - rp2350
+          - stm32
     runs-on: ubuntu-24.04
     steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v6
       - uses: actions/setup-python@v6
         with:
           python-version: 3.x
@@ -42,43 +51,20 @@ jobs:
       - run: pip install -U platformio
       - name: Generate matrix
         id: jsonStep
-        env:
-          BUILDTARGET: ${{ inputs.target }}
-          MATRIXARCH: ${{ inputs.arch }}
         run: |
           TARGETS=$(./bin/generate_ci_matrix.py ${{matrix.arch}} --level extra)
-          if [ "$BUILDTARGET" = "" ]; then
-            echo "Name: $GITHUB_REF_NAME" >> $GITHUB_STEP_SUMMARY
-            echo "Base: $GITHUB_BASE_REF" >> $GITHUB_STEP_SUMMARY
-            echo "Arch: $MATRIXARCH" >> $GITHUB_STEP_SUMMARY
-            echo "Ref: $GITHUB_REF" >> $GITHUB_STEP_SUMMARY
-            echo "## 🎯 The following target boards are available to build:" >> $GITHUB_STEP_SUMMARY
-            echo "| Platform | Board |" >> $GITHUB_STEP_SUMMARY
-            echo "| -------- | ----- |" >> $GITHUB_STEP_SUMMARY
-            echo $TARGETS | jq -r 'sort_by(.board) | sort_by(.platform) |.[] | "| " + .platform + " | " + .board + " |" ' >> $GITHUB_STEP_SUMMARY
-          else
-            echo "We build this one:" >> $GITHUB_STEP_SUMMARY
-            ARCH=$(echo "$TARGETS" | jq --arg BUILDTARGET "$BUILDTARGET" -r '.[] | select(.board==$BUILDTARGET) | .platform')
-            echo "| Platform | Board |" >> $GITHUB_STEP_SUMMARY
-            echo "| -------- | ----- |" >> $GITHUB_STEP_SUMMARY
-            echo "| $ARCH | "$BUILDTARGET" |" >> $GITHUB_STEP_SUMMARY
-            echo "" >> $GITHUB_STEP_SUMMARY
-            if [[ "$ARCH" == "" ]]; then
-              echo "## ❌ Error: Target "$BUILDTARGET" not found!" >> $GITHUB_STEP_SUMMARY
-            else
-              echo "## ✅ Target "$BUILDTARGET" found, proceeding to build." >> $GITHUB_STEP_SUMMARY
-            fi
-            echo "You may need to refresh this page to make the built firmware appear below." >> $GITHUB_STEP_SUMMARY
-            echo "arch=$ARCH" >> $GITHUB_OUTPUT
-          fi
-    outputs:
-      arch: ${{ steps.jsonStep.outputs.arch }}
+          echo "Name: $GITHUB_REF_NAME" >> $GITHUB_STEP_SUMMARY
+          echo "Base: $GITHUB_BASE_REF" >> $GITHUB_STEP_SUMMARY
+          echo "Arch: ${{matrix.arch}}" >> $GITHUB_STEP_SUMMARY
+          echo "Ref: $GITHUB_REF" >> $GITHUB_STEP_SUMMARY
+          echo "Targets:" >> $GITHUB_STEP_SUMMARY
+          echo $TARGETS | jq -r 'sort_by(.board) |.[] | "- " + .board' >> $GITHUB_STEP_SUMMARY
 
   version:
     if: ${{ inputs.target != '' }}
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v6
       - name: Get release version string
         run: |
           echo "long=$(./bin/buildinfo.py long)" >> $GITHUB_OUTPUT
@@ -92,12 +78,12 @@ jobs:
 
   build:
     if: ${{ inputs.target != '' && inputs.arch != 'native' }}
-    needs: [version, find-targets]
+    needs: [version]
     uses: ./.github/workflows/build_firmware.yml
     with:
       version: ${{ needs.version.outputs.long }}
       pio_env: ${{ inputs.target }}
-      platform: ${{ needs.find-targets.outputs.arch }}
+      platform: ${{ inputs.arch }}
 
   gather-artifacts:
     permissions:
@@ -107,7 +93,7 @@ jobs:
     needs: [version, build]
     steps:
       - name: Checkout code
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           ref: ${{github.event.pull_request.head.ref}}
           repository: ${{github.event.pull_request.head.repo.full_name}}

.github/workflows/build_portduino_wasm.yml

@@ -1,81 +0,0 @@
-name: Build PortDuino WASM
-
-# Reusable workflow - called as the `build-wasm` job of the main CI workflow
-# (main_matrix.yml), so the WebAssembly portduino node is built like every other
-# platform. Builds the [env:native-wasm] target (src/platform/portduino/wasm/) with
-# `pio run -e native-wasm` so it can't silently bit-rot. Software/CI only - asserts the
-# full mesh stack + RadioLib + Crypto compile and link to meshnode.{mjs,wasm}
-# via the meshtastic/platform-wasm PlatformIO platform (emcc/Asyncify). It does
-# NOT exercise the radio (that's CH341/WebUSB, hardware).
-
-on:
-  workflow_call:
-  workflow_dispatch:
-
-permissions: {}
-
-jobs:
-  build-wasm:
-    name: Build PortDuino WASM
-    runs-on: ubuntu-latest
-    # Only pushes to the default branch (develop) populate the cache; PR / merge_group runs
-    # restore it but never save, so they stop filling up the repo's Actions cache storage.
-    env:
-      SAVE_CACHE: ${{ github.event_name == 'push' && github.ref_name == github.event.repository.default_branch }}
-    steps:
-      - uses: actions/checkout@v7
-        with:
-          submodules: recursive
-
-      # Python + PlatformIO. (`pio run -e native-wasm` installs its own libdeps and the
-      # platform-wasm/framework-portduino packages; it needs no native apt libs.)
-      - name: Setup native build
-        uses: ./.github/actions/setup-native
-
-      - name: Setup Emscripten SDK
-        uses: emscripten-core/setup-emsdk@0822153d7a5488b70a269cfa0a631b2a86ab4da2 # 'v17' main
-        with:
-          version: 6.0.1
-          actions-cache-folder: emsdk-cache
-
-      - name: Restore PlatformIO cache
-        id: pio-cache
-        uses: actions/cache/restore@v6
-        with:
-          path: ~/.platformio/.cache
-          key: pio-wasm-${{ hashFiles('platformio.ini', 'variants/native/portduino.ini', 'variants/native/portduino/platformio.ini') }}
-          restore-keys: |
-            pio-wasm-
-
-      - name: Build PortDuino WASM
-        run: platformio run -e native-wasm
-
-      - name: Save PlatformIO cache
-        if: env.SAVE_CACHE == 'true' && steps.pio-cache.outputs.cache-hit != 'true'
-        uses: actions/cache/save@v6
-        with:
-          path: ~/.platformio/.cache
-          key: pio-wasm-${{ hashFiles('platformio.ini', 'variants/native/portduino.ini', 'variants/native/portduino/platformio.ini') }}
-
-      - name: Assert WASM artifacts
-        run: |
-          OUT=.pio/build/native-wasm
-          if [ ! -s "$OUT/meshnode.mjs" ] || [ ! -s "$OUT/meshnode.wasm" ]; then
-            echo "::error::wasm artifacts missing"; exit 1
-          fi
-          # The emcc link succeeds even if embedded EM_ASM JS is malformed, so
-          # parse the generated ES-module loader to catch runtime-JS breakage
-          # (e.g. a formatter splitting !== inside EM_ASM).
-          node --check "$OUT/meshnode.mjs" || { echo "::error::meshnode.mjs failed JS parse"; exit 1; }
-          ls -lah "$OUT"/meshnode.*
-
-      - name: Upload WASM artifacts
-        if: success()
-        uses: actions/upload-artifact@v7
-        with:
-          name: portduino-wasm
-          overwrite: true
-          path: |
-            .pio/build/native-wasm/meshnode.mjs
-            .pio/build/native-wasm/meshnode.wasm
-          retention-days: 14

.github/workflows/build_windows_bin.yml

@@ -1,165 +0,0 @@
-name: Build Windows Binary
-
-on:
-  workflow_call:
-    inputs:
-      windows_ver:
-        required: false
-        default: "2025"
-        type: string
-
-permissions:
-  contents: read
-
-jobs:
-  build-Windows:
-    runs-on: windows-${{ inputs.windows_ver }}
-    # Only pushes to the default branch (develop) populate the cache; PR / merge_group runs
-    # restore it but never save, so they stop filling up the repo's Actions cache storage.
-    env:
-      SAVE_CACHE: ${{ github.event_name == 'push' && github.ref_name == github.event.repository.default_branch }}
-    defaults:
-      run:
-        # UCRT64 is the MinGW-w64 environment native-windows targets; the `msys`
-        # environment would link msys-2.0.dll and produce a Cygwin-style binary.
-        shell: msys2 {0}
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v7
-        with:
-          submodules: recursive
-          # Keep the token out of .git/config so later steps and artifacts can't leak it.
-          persist-credentials: false
-
-      - name: Setup MSYS2 / UCRT64
-        id: msys2
-        uses: msys2/setup-msys2@v2
-        with:
-          msystem: UCRT64
-          update: true
-          cache: true
-          # argp is not packaged for the mingw environments and is built below.
-          # Python is omitted too: MSYS2's reports a `mingw` platform tag no wheel matches.
-          install: >-
-            mingw-w64-ucrt-x86_64-gcc
-            mingw-w64-ucrt-x86_64-pkgconf
-            mingw-w64-ucrt-x86_64-yaml-cpp
-            mingw-w64-ucrt-x86_64-libuv
-            mingw-w64-ucrt-x86_64-jsoncpp
-            mingw-w64-ucrt-x86_64-openssl
-            mingw-w64-ucrt-x86_64-curl
-            mingw-w64-ucrt-x86_64-libusb
-            mingw-w64-ucrt-x86_64-cmake
-            mingw-w64-ucrt-x86_64-ninja
-            git
-
-      - name: Setup Python
-        uses: actions/setup-python@v6
-        with:
-          python-version: "3.14"
-          cache: pip
-
-      # framework-portduino calls argp_parse(); MSYS2 packages argp only for the
-      # msys runtime, which cannot link into a native binary. No install() rules.
-      - name: Build and install argp-standalone
-        run: |
-          git clone --depth 1 https://github.com/tom42/argp-standalone /tmp/argp
-          cd /tmp/argp
-          cmake -G Ninja -B build -DCMAKE_BUILD_TYPE=Release .
-          cmake --build build
-          cp include/argp-standalone/argp.h /ucrt64/include/argp.h
-          cp build/src/libargp-standalone.a /ucrt64/lib/libargp.a
-
-      - name: Install PlatformIO
-        shell: pwsh
-        run: |
-          python -m pip install --upgrade pip
-          pip install platformio
-
-      - name: Restore PlatformIO cache
-        id: pio-cache
-        uses: actions/cache/restore@v6
-        with:
-          path: ~/.platformio/.cache
-          key: pio-windows-${{ inputs.windows_ver }}-${{ hashFiles('platformio.ini', 'variants/native/portduino.ini', 'variants/native/portduino/platformio.ini') }}
-          restore-keys: |
-            pio-windows-${{ inputs.windows_ver }}-
-
-      - name: Get release version string
-        shell: pwsh
-        id: version
-        run: echo "long=$(python ./bin/buildinfo.py long)" >> $env:GITHUB_OUTPUT
-
-      # Runs outside the MSYS2 shell so PlatformIO stays on the runner's
-      # CPython; the UCRT64 toolchain is reached through PATH instead.
-      - name: Build for Windows
-        shell: pwsh
-        run: |
-          $env:PATH = "${{ steps.msys2.outputs.msys2-location }}\ucrt64\bin;$env:PATH"
-          platformio run -e native-windows
-        env:
-          PKG_VERSION: ${{ steps.version.outputs.long }}
-
-      - name: Save PlatformIO cache
-        if: env.SAVE_CACHE == 'true' && steps.pio-cache.outputs.cache-hit != 'true'
-        uses: actions/cache/save@v6
-        with:
-          path: ~/.platformio/.cache
-          key: pio-windows-${{ inputs.windows_ver }}-${{ hashFiles('platformio.ini', 'variants/native/portduino.ini', 'variants/native/portduino/platformio.ini') }}
-
-      - name: List output files
-        run: ls -lah .pio/build/native-windows/
-
-      # The env links statically, so only Windows system DLLs should appear here.
-      # A third-party DLL means the static link regressed.
-      - name: Verify the binary is self-contained
-        run: |
-          set -euo pipefail
-          bin=.pio/build/native-windows/meshtasticd.exe
-          test -f "$bin"
-          # `|| true` keeps grep's no-match exit out of `set -e`; an empty import
-          # table is caught by the test below instead of passing as "no deps".
-          deps=$(objdump -p "$bin" | grep -i 'DLL Name' || true)
-          test -n "$deps"
-          extra=$(printf '%s\n' "$deps" \
-            | grep -viE 'api-ms-win|KERNEL32|WS2_32|ADVAPI32|USER32|msvcrt|ucrtbase|bcrypt|IPHLPAPI|SHELL32|ole32|CRYPT32|SETUPAPI|CFGMGR32|WINMM|dbghelp' || true)
-          if [ -n "$extra" ]; then
-            printf '%s\n' "$extra"
-            echo "::error::meshtasticd.exe has non-system DLL dependencies (static link regressed)"
-            exit 1
-          fi
-          echo "OK: no third-party DLL dependencies"
-
-      - name: Smoke test the binary
-        run: |
-          .pio/build/native-windows/meshtasticd.exe --version
-
-      - name: Store binaries as an artifact
-        uses: actions/upload-artifact@v7
-        with:
-          name: firmware-windows-${{ inputs.windows_ver }}-${{ steps.version.outputs.long }}
-          overwrite: true
-          path: |
-            .pio/build/native-windows/meshtasticd.exe
-
-      - name: Install WiX
-        shell: pwsh
-        run: |
-          dotnet tool install --global wix --version 5.0.2
-          "$env:USERPROFILE\.dotnet\tools" | Out-File -FilePath $env:GITHUB_PATH -Append -Encoding utf8
-          & "$env:USERPROFILE\.dotnet\tools\wix.exe" extension add -g WixToolset.Util.wixext/5.0.2
-
-      - name: Build the MSI and winget manifests
-        shell: pwsh
-        run: ./bin/build-winget-package.ps1 -ReleaseTag "v$env:LONG_VERSION" -Validate
-        env:
-          LONG_VERSION: ${{ steps.version.outputs.long }}
-
-      - name: Store the MSI and winget manifests as an artifact
-        uses: actions/upload-artifact@v7
-        with:
-          name: meshtasticd-msi-${{ inputs.windows_ver }}-${{ steps.version.outputs.long }}
-          overwrite: true
-          path: |
-            release/winget/*.msi
-            release/winget/manifests/

.github/workflows/daily_packaging.yml

@@ -35,8 +35,8 @@ jobs:
         series:
           - jammy # 22.04 LTS
           - noble # 24.04 LTS
+          - questing # 25.10
           - resolute # 26.04 LTS
-          - stonking # 26.10
     uses: ./.github/workflows/package_ppa.yml
     with:
       ppa_repo: ppa:meshtastic/daily

.github/workflows/docker_build.yml

@@ -45,13 +45,9 @@ jobs:
     outputs:
       digest: ${{ steps.docker_variant.outputs.digest }}
     runs-on: ${{ inputs.runs-on }}
-    env:
-      # Only cache on default branch (develop).
-      # 'docker/' actions don't support separate Restore/Save actions, so we have to disable caching entirely on PRs/merge_queue.
-      USE_CACHE: ${{ github.ref_name == github.event.repository.default_branch }}
     steps:
       - name: Checkout code
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           submodules: recursive
 
@@ -63,12 +59,11 @@ jobs:
       - name: Set up QEMU
         uses: docker/setup-qemu-action@v4
         with:
-          cache-image: ${{ env.USE_CACHE }}
+          cache-image: true
 
       - name: Docker setup
         uses: docker/setup-buildx-action@v4
         with:
-          cache-binary: ${{ env.USE_CACHE }}
           # Add Google/Amazon DockerHub mirrors to buildkit config
           # https://docs.docker.com/build/ci/github-actions/configure-builder/#registry-mirror
           buildkitd-config-inline: |
@@ -82,20 +77,13 @@ jobs:
           plat: ${{ inputs.platform }}
         run: echo "cleaned_platform=${plat}" | sed 's/\//_/g' >> $GITHUB_OUTPUT
 
-      - name: DockerHub login
+      - name: Docker login
         if: ${{ inputs.push }}
         uses: docker/login-action@v4
         with:
           username: meshtastic
           password: ${{ secrets.DOCKER_FIRMWARE_TOKEN }}
 
-      - name: GHCR login
-        uses: docker/login-action@v4
-        with:
-          registry: ghcr.io
-          username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-
       - name: Docker tag
         id: meta
         uses: docker/metadata-action@v6
@@ -105,19 +93,6 @@ jobs:
             GHA-${{ steps.version.outputs.long }}-${{ inputs.distro }}-${{ steps.sanitize_platform.outputs.cleaned_platform }}
           flavor: latest=false
 
-      - name: Docker setup caching
-        id: docker-cache
-        env:
-          BASE_REF: ${{ github.event.merge_group.base_ref || github.event.pull_request.base.ref || github.ref_name }}
-        run: |
-          base=$(echo "${BASE_REF#refs/heads/}" | sed 's/\//_/g')
-          ref=ghcr.io/${{ github.repository }}-cache:${base}-${{ inputs.distro }}-${{ steps.sanitize_platform.outputs.cleaned_platform }}
-          echo "cache_from=type=registry,ref=${ref}" >> $GITHUB_OUTPUT
-          case "${GITHUB_EVENT_NAME}" in
-            merge_group|pull_request) ;;
-            *) echo "cache_to=type=registry,ref=${ref},mode=max,ignore-error=true" >> $GITHUB_OUTPUT ;;
-          esac
-
       - name: Docker build and push
         uses: docker/build-push-action@v7
         id: docker_variant
@@ -130,6 +105,6 @@ jobs:
           platforms: ${{ inputs.platform }}
           build-args: |
             PIO_ENV=${{ inputs.pio_env }}
-          # Cache image layers in GitHub Container Registry to speed up subsequent builds.
-          cache-from: ${{ steps.docker-cache.outputs.cache_from }}
-          cache-to: ${{ steps.docker-cache.outputs.cache_to || '' }}
+          # Cache image layers in GitHub Actions cache to speed up subsequent builds.
+          cache-from: type=gha
+          cache-to: type=gha,mode=max

.github/workflows/docker_manifest.yml

@@ -103,7 +103,7 @@ jobs:
     runs-on: ubuntu-24.04
     steps:
       - name: Checkout code
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           submodules: recursive
 

.github/workflows/firmware-size-comment.yml

@@ -1,62 +0,0 @@
-name: Post Firmware Size Comment
-
-on:
-  workflow_run:
-    workflows: [CI]
-    types: [completed]
-
-permissions:
-  pull-requests: write
-  actions: read
-
-jobs:
-  post-size-comment:
-    if: >
-      github.event.workflow_run.event == 'pull_request' &&
-      github.event.workflow_run.conclusion != 'cancelled' &&
-      github.repository == 'meshtastic/firmware'
-    continue-on-error: true
-    runs-on: ubuntu-latest
-    steps:
-      - name: Download size report
-        id: download
-        uses: actions/download-artifact@v8
-        continue-on-error: true
-        with:
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-          run-id: ${{ github.event.workflow_run.id }}
-          name: size-report
-          path: ./
-
-      - name: Post or update PR comment
-        if: steps.download.outcome == 'success'
-        uses: actions/github-script@v9
-        with:
-          script: |
-            const fs = require('fs');
-            const marker = '<!-- firmware-size-report -->';
-            const body = fs.readFileSync('./size-report.md', 'utf8');
-            const prNumber = parseInt(fs.readFileSync('./pr-number.txt', 'utf8').trim(), 10);
-
-            const { data: comments } = await github.rest.issues.listComments({
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              issue_number: prNumber,
-            });
-
-            const existing = comments.find(c => c.body.includes(marker));
-            if (existing) {
-              await github.rest.issues.updateComment({
-                owner: context.repo.owner,
-                repo: context.repo.repo,
-                comment_id: existing.id,
-                body,
-              });
-            } else {
-              await github.rest.issues.createComment({
-                owner: context.repo.owner,
-                repo: context.repo.repo,
-                issue_number: prNumber,
-                body,
-              });
-            }

.github/workflows/flasher-link-comment.yml

@@ -1,187 +0,0 @@
-name: Post Web Flasher Link Comment
-
-on:
-  workflow_run:
-    workflows: [CI]
-    types: [completed]
-
-permissions:
-  pull-requests: write
-  actions: read
-
-jobs:
-  post-flasher-link:
-    if: >
-      github.event.workflow_run.event == 'pull_request' &&
-      github.event.workflow_run.conclusion != 'cancelled' &&
-      github.repository == 'meshtastic/firmware'
-    continue-on-error: true
-    runs-on: ubuntu-latest
-    steps:
-      # Per-board manifests carry the firmware's own metadata (activelySupported,
-      # displayName, ...) generated from each target's custom_meshtastic_* config.
-      - name: Download board manifests
-        uses: actions/download-artifact@v8
-        continue-on-error: true
-        with:
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-          run-id: ${{ github.event.workflow_run.id }}
-          pattern: manifest-*
-          path: ./manifests
-          merge-multiple: true
-
-      - name: Post or update web flasher link comment
-        uses: actions/github-script@v9
-        with:
-          script: |
-            const marker = '<!-- web-flasher-link -->';
-            const run = context.payload.workflow_run;
-            const { owner, repo } = context.repo;
-
-            // Resolve the PR by matching the run's head SHA against the repo's open
-            // PRs. workflow_run.pull_requests is empty for fork PRs, and
-            // listPullRequestsAssociatedWithCommit won't return an open fork PR by
-            // its head commit - but pulls.list includes fork PRs. Matching on head
-            // SHA also enforces that the run is for the PR's current commit, so stale
-            // re-runs of an outdated commit won't match.
-            const openPrs = await github.paginate(github.rest.pulls.list, {
-              owner, repo, state: 'open', per_page: 100,
-            });
-            const pr = openPrs.find((p) => p.head.sha === run.head_sha);
-            if (!pr) {
-              core.info(`No open pull request matches commit ${run.head_sha}; skipping.`);
-              return;
-            }
-            const prNumber = pr.number;
-
-            // Restrict to trusted authors. NOTE: author_association is computed for
-            // the GITHUB_TOKEN, which cannot see *private/concealed* org memberships -
-            // those members come back as CONTRIBUTOR, not MEMBER. So gating on MEMBER
-            // alone silently excludes most maintainers. We allow the trusted set the
-            // token can actually identify (members, collaborators, and anyone with a
-            // previously merged PR). For strict members-only you'd need an org-read
-            // App/PAT token to call orgs.checkMembershipForUser.
-            const allowedAssociations = ['OWNER', 'MEMBER', 'COLLABORATOR', 'CONTRIBUTOR'];
-            if (!allowedAssociations.includes(pr.author_association)) {
-              core.info(`Author association ${pr.author_association} is not trusted; skipping.`);
-              return;
-            }
-
-            // Require at least one per-arch firmware artifact from gather-artifacts
-            const artifacts = await github.paginate(github.rest.actions.listWorkflowRunArtifacts, {
-              owner, repo, run_id: run.id, per_page: 100,
-            });
-            const archRe = /^firmware-(esp32|esp32s3|esp32c3|esp32c6|nrf52840|rp2040|rp2350|stm32)-(\d+\.\d+\.\d+\.[0-9a-f]+)$/;
-            const archArtifacts = artifacts.filter((a) => archRe.test(a.name) && !a.expired);
-            if (archArtifacts.length === 0) {
-              core.info('No per-arch firmware artifacts found; skipping.');
-              return;
-            }
-
-            const version = archRe.exec(archArtifacts[0].name)[2];
-            const expiresAt = archArtifacts[0].expires_at
-              ? new Date(archArtifacts[0].expires_at).toISOString().slice(0, 10)
-              : null;
-
-            // Read each built board's manifest (.mt.json). activelySupported,
-            // displayName and architecture come straight from the board's
-            // custom_meshtastic_* platformio config, so the list is in sync with
-            // the firmware itself - no external device database needed.
-            const fs = require('fs');
-            let boards = [];
-            try {
-              boards = fs.readdirSync('./manifests')
-                .filter((f) => f.endsWith('.mt.json'))
-                .map((f) => {
-                  try { return JSON.parse(fs.readFileSync(`./manifests/${f}`, 'utf8')); }
-                  catch { return null; }
-                })
-                .filter((m) => m && m.activelySupported === true && m.platformioTarget)
-                .map((m) => ({
-                  board: m.platformioTarget,
-                  platform: m.architecture || '',
-                  // displayName is maintainer-authored text; escape table-breaking pipes
-                  displayName: String(m.displayName || m.platformioTarget).replace(/\|/g, '\\|'),
-                  image: Array.isArray(m.images) && m.images[0] ? String(m.images[0]) : '',
-                }))
-                .sort((a, b) => a.board.localeCompare(b.board));
-            } catch (e) {
-              core.warning(`Could not read board manifests: ${e.message}`);
-            }
-
-            const flasherUrl = `https://flasher.meshtastic.org/?pr=${prNumber}`;
-            // Device illustrations are served by the flasher from the same image
-            // names the manifest declares (custom_meshtastic_images). The flasher
-            // serves its SPA shell (HTML, 200) for unknown paths, so confirm each
-            // image really resolves to an image before linking it.
-            const imageBase = 'https://flasher.meshtastic.org/img/devices/';
-            await Promise.all(boards.map(async (b) => {
-              if (!b.image) return;
-              try {
-                const res = await fetch(`${imageBase}${encodeURIComponent(b.image)}`);
-                const type = res.headers.get('content-type') || '';
-                if (!res.ok || !type.startsWith('image/')) b.image = '';
-              } catch { b.image = ''; }
-            }));
-
-            const boardLines = boards
-              .map((b) => {
-                const img = b.image ? `<img src="${imageBase}${encodeURIComponent(b.image)}" alt="" height="34">` : '';
-                return `| ${img} | ${b.displayName} | [\`${b.board}\`](${flasherUrl}&device=${encodeURIComponent(b.board)}) | ${b.platform} |`;
-              })
-              .join('\n');
-
-            // Shields.io badges. Only non-user-controlled, charset-constrained values
-            // (version, commit sha, counts, dates) go into badge URLs - never board
-            // names or the PR title - so the rendered comment cannot be spoofed.
-            const shieldText = (s) =>
-              encodeURIComponent(String(s).replace(/-/g, '--').replace(/_/g, '__').replace(/ /g, '_'));
-            const shield = (label, message, color) =>
-              `https://img.shields.io/badge/${shieldText(label)}-${shieldText(message)}-${color}`;
-            const buttonUrl =
-              `https://img.shields.io/badge/${shieldText('Flash this PR in the Web Flasher')}-2C2D3C?style=for-the-badge`;
-            const badges = [
-              `![firmware](${shield('firmware', version, '67EA94')})`,
-              `![commit](${shield('commit', run.head_sha.slice(0, 7), '2C2D3C')})`,
-              `![boards](${shield('boards', boards.length, '5C6BC0')})`,
-            ];
-            if (expiresAt) badges.push(`![expires](${shield('expires', expiresAt, '9A4E00')})`);
-
-            // Only render the board table when there are supported boards to list
-            const boardTable = boards.length > 0 ? [
-              `<details><summary>Supported boards built by this PR (${boards.length})</summary>`,
-              '',
-              '| | Device | Board | Platform |',
-              '| --- | --- | --- | --- |',
-              boardLines,
-              '',
-              '</details>',
-              '',
-            ] : [];
-
-            const body = [
-              marker,
-              '## ⚡ Try this PR in the Web Flasher',
-              '',
-              `[![Flash this PR in the Web Flasher](${buttonUrl})](${flasherUrl})`,
-              '',
-              badges.join(' '),
-              '',
-              '> [!WARNING]',
-              '> This is an automated, unreviewed CI test build. Back up your device configuration',
-              '> before flashing, and only flash devices you are able to recover.',
-              '',
-              ...boardTable,
-              `*Build artifacts expire${expiresAt ? ` on ${expiresAt}` : ' after 30 days'}. Updated for \`${run.head_sha.slice(0, 7)}\`.*`,
-            ].join('\n');
-
-            // Sticky comment: update in place when the marker is found
-            const comments = await github.paginate(github.rest.issues.listComments, {
-              owner, repo, issue_number: prNumber, per_page: 100,
-            });
-            const existing = comments.find((c) => c.body?.includes(marker));
-            if (existing) {
-              await github.rest.issues.updateComment({ owner, repo, comment_id: existing.id, body });
-            } else {
-              await github.rest.issues.createComment({ owner, repo, issue_number: prNumber, body });
-            }

.github/workflows/flasher-link-placeholder.yml

@@ -1,62 +0,0 @@
-name: Post Web Flasher Build Placeholder
-
-# Drops an immediate "build in progress" comment when a PR opens, so the web
-# flasher entry shows up right away. The real CI-driven workflow
-# (flasher-link-comment.yml) later replaces it in place via the shared marker.
-#
-# SECURITY: this uses pull_request_target (write token, runs for fork PRs) but is
-# safe because it never checks out or runs PR code and posts a fully static body
-# - no PR title, branch name, or other untrusted input is used anywhere.
-
-on:
-  pull_request_target:
-    types: [opened, reopened]
-
-permissions:
-  pull-requests: write
-
-jobs:
-  post-placeholder:
-    if: github.repository == 'meshtastic/firmware'
-    continue-on-error: true
-    runs-on: ubuntu-latest
-    steps:
-      - name: Post web flasher build-in-progress placeholder
-        uses: actions/github-script@v9
-        with:
-          script: |
-            const marker = '<!-- web-flasher-link -->';
-            const { owner, repo } = context.repo;
-            const pr = context.payload.pull_request;
-
-            // Trusted authors only (matches the real workflow). author_association
-            // can't reflect private org membership for the token, so concealed
-            // members appear as CONTRIBUTOR - include it, or maintainers are excluded.
-            const allowedAssociations = ['OWNER', 'MEMBER', 'COLLABORATOR', 'CONTRIBUTOR'];
-            if (!allowedAssociations.includes(pr.author_association)) {
-              core.info(`Author association ${pr.author_association} is not trusted; skipping.`);
-              return;
-            }
-
-            // Only seed a placeholder when no flasher comment exists yet - never
-            // overwrite a real (or existing placeholder) comment.
-            const comments = await github.paginate(github.rest.issues.listComments, {
-              owner, repo, issue_number: pr.number, per_page: 100,
-            });
-            if (comments.some((c) => c.body?.includes(marker))) {
-              core.info('Flasher comment already exists; nothing to do.');
-              return;
-            }
-
-            const body = [
-              marker,
-              '## ⚡ Try this PR in the Web Flasher',
-              '',
-              '> [!NOTE]',
-              '> Building this pull request… the flash button, badges and supported-board',
-              '> list will appear here automatically once CI finishes.',
-            ].join('\n');
-
-            await github.rest.issues.createComment({
-              owner, repo, issue_number: pr.number, body,
-            });

.github/workflows/hook_copr.yml

@@ -18,7 +18,7 @@ jobs:
     runs-on: ubuntu-24.04
     steps:
       - name: Checkout code
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           submodules: recursive
 

.github/workflows/main_matrix.yml

@@ -3,21 +3,12 @@ concurrency:
   group: ci-${{ github.head_ref || github.run_id }}
   cancel-in-progress: true
 on:
-  # The merge queue is the pre-merge gate for the protected branches (master,
-  # develop): a merge_group run validates the merged result before code lands. For
-  # now PRs and merge_group runs build the same narrowed board subset (--level pr);
-  # see the setup job. push still runs the full matrix on master/develop (post-merge)
-  # as well as on the event/* and feature/* branches, which have no merge queue.
-  merge_group:
-    types: [checks_requested]
-    branches:
-      - master
-      - develop
-
+  # # Triggers the workflow on push but only for the main branches
   push:
     branches:
       - master
       - develop
+      - pioarduino # Remove when merged // use `feature/` in the future.
       - event/*
       - feature/*
     paths-ignore:
@@ -28,36 +19,28 @@ on:
     branches:
       - master
       - develop
+      - pioarduino # Remove when merged // use `feature/` in the future.
       - event/*
       - feature/*
     paths-ignore:
       - "**.md"
       #- "**.yml"
 
-  schedule:
-    # Nightly develop build, published to meshtastic.github.io firmware-nightly/ (no GitHub release).
-    # Scheduled runs execute on the default branch (develop). 07:00 UTC avoids the 00:00 tests
-    # and 02:00 daily_packaging crons.
-    - cron: 0 7 * * * # Nightly develop build/publish (default branch is develop)
-
   workflow_dispatch:
-    inputs:
-      # trunk-ignore(checkov/CKV_GHA_7): intentional manual-test switch for the nightly publish path
-      nightly:
-        description: "Nightly mode: build + publish develop to github.io firmware-nightly/ (skips creating a GitHub release)"
-        type: boolean
-        default: false
 
 permissions: read-all
 
 jobs:
   setup:
+    strategy:
+      fail-fast: true
+      matrix:
+        arch:
+          - all
+          - check
     runs-on: ubuntu-24.04
     steps:
-      - uses: actions/checkout@v7
-        with:
-          # Needed to diff against the base branch for newly added variants.
-          fetch-depth: 0
+      - uses: actions/checkout@v6
       - uses: actions/setup-python@v6
         with:
           python-version: 3.x
@@ -65,46 +48,23 @@ jobs:
       - run: pip install -U platformio
       - name: Generate matrix
         id: jsonStep
-        env:
-          BASE_REF: ${{ github.base_ref }}
-          MERGE_GROUP_BASE_SHA: ${{ github.event.merge_group.base_sha }}
         run: |
-          # A new board is 'release' and gets no CI until after merge, so force-build the
-          # first env of each ADDED variant config. A new env in an existing one does not count.
-          DIFF_BASE=""
-          if [[ "$GITHUB_EVENT_NAME" == "pull_request" ]]; then
-            git fetch --no-tags --depth=1 origin "$BASE_REF"
-            DIFF_BASE=$(git merge-base FETCH_HEAD HEAD)
-          elif [[ "$GITHUB_EVENT_NAME" == "merge_group" ]]; then
-            DIFF_BASE="$MERGE_GROUP_BASE_SHA"
-          fi
-          ADDED_ARGS=()
-          if [[ -n "$DIFF_BASE" ]]; then
-            # Assign rather than pipe: a failing diff must abort the step under 'set -e',
-            # not silently yield an empty list and drop the new board from the matrix.
-            ADDED_CONFIGS=$(git diff --name-only --diff-filter=A \
-              "$DIFF_BASE" HEAD -- 'variants/**/platformio.ini')
-            while IFS= read -r cfg; do
-              [[ -n "$cfg" ]] && ADDED_ARGS+=(--added-config "$cfg")
-            done <<<"$ADDED_CONFIGS"
-          fi
-          # PRs and (for now) merge_group builds use the narrowed --level pr board
-          # subset. Full-matrix builds run on push / schedule / workflow_dispatch.
-          if [[ "$GITHUB_EVENT_NAME" == "pull_request" || "$GITHUB_EVENT_NAME" == "merge_group" ]]; then
-            TARGETS=$(./bin/generate_ci_matrix.py all --level pr "${ADDED_ARGS[@]}")
-          else
-            TARGETS=$(./bin/generate_ci_matrix.py all)
+          if [[ "$GITHUB_HEAD_REF" == "" ]]; then
+            TARGETS=$(./bin/generate_ci_matrix.py ${{matrix.arch}})
+          else  
+            TARGETS=$(./bin/generate_ci_matrix.py ${{matrix.arch}} --level pr)
           fi
           echo "Name: $GITHUB_REF_NAME Base: $GITHUB_BASE_REF Ref: $GITHUB_REF"
-          echo "all=$TARGETS" >> $GITHUB_OUTPUT
+          echo "${{matrix.arch}}=$TARGETS" >> $GITHUB_OUTPUT
           echo "$TARGETS" >> $GITHUB_STEP_SUMMARY
     outputs:
       all: ${{ steps.jsonStep.outputs.all }}
+      check: ${{ steps.jsonStep.outputs.check }}
 
   version:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v6
       - name: Get release version string
         run: |
           echo "long=$(./bin/buildinfo.py long)" >> $GITHUB_OUTPUT
@@ -121,14 +81,12 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        check: ${{ fromJson(needs.setup.outputs.all) }}
-    # Runs on GitHub-hosted runners so checks don't compete with builds for the
-    # self-hosted 'arctastic' pool (which builds use).
-    runs-on: ubuntu-latest
-    # Only run checks for PRs and Merge Queue runs.
-    if: contains(fromJSON('["pull_request", "merge_group"]'), github.event_name)
+        check: ${{ fromJson(needs.setup.outputs.check) }}
+    # Use 'arctastic' self-hosted runner pool when checking in the main repo
+    runs-on: ${{ github.repository_owner == 'meshtastic' && 'arctastic' || 'ubuntu-latest' }}
+    if: ${{ github.event_name != 'workflow_dispatch' && github.repository == 'meshtastic/firmware' }}
     steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v6
         with:
           submodules: recursive
       - name: Check ${{ matrix.check.board }}
@@ -151,7 +109,7 @@ jobs:
       platform: ${{ matrix.build.platform }}
 
   build-debian-src:
-    if: github.repository_owner == 'meshtastic' && github.event_name != 'schedule' && github.event.inputs.nightly != 'true'
+    if: github.repository == 'meshtastic/firmware'
     uses: ./.github/workflows/build_debian_src.yml
     with:
       series: UNRELEASED
@@ -159,7 +117,6 @@ jobs:
     secrets: inherit
 
   MacOS:
-    if: github.event_name != 'schedule' && github.event.inputs.nightly != 'true' && !contains(github.ref_name, 'event/')
     strategy:
       fail-fast: false
       matrix:
@@ -173,44 +130,22 @@ jobs:
       macos_ver: ${{ matrix.macos_ver }}
     # secrets: inherit
 
-  Windows:
-    if: github.event_name != 'schedule' && github.event.inputs.nightly != 'true' && !contains(github.ref_name, 'event/')
-    strategy:
-      fail-fast: false
-      matrix:
-        windows_ver:
-          - "2025" # x86_64
-    uses: ./.github/workflows/build_windows_bin.yml
-    with:
-      windows_ver: ${{ matrix.windows_ver }}
-    # secrets: inherit
-
   package-pio-deps-native-tft:
-    if: github.repository_owner == 'meshtastic' && github.event_name == 'workflow_dispatch'
+    if: ${{ github.repository == 'meshtastic/firmware' && github.event_name == 'workflow_dispatch' }}
     uses: ./.github/workflows/package_pio_deps.yml
     with:
       pio_env: native-tft
     secrets: inherit
 
   test-native:
-    if: github.repository_owner == 'meshtastic' && github.event_name != 'schedule' && github.event.inputs.nightly != 'true' && !contains(github.ref_name, 'event/')
+    if: ${{ !contains(github.ref_name, 'event/') && github.repository == 'meshtastic/firmware' }}
     permissions: # Needed for dorny/test-reporter.
       contents: read
       actions: read
       checks: write
     uses: ./.github/workflows/test_native.yml
 
-  build-wasm:
-    if: github.event_name != 'schedule' && github.event.inputs.nightly != 'true' && !contains(github.ref_name, 'event/')
-    # Build the WebAssembly portduino node ([env:native-wasm]) as part of normal CI,
-    # like the other platforms. It's a dedicated job (not a row in the `build`
-    # matrix) because its artifact is meshnode.{mjs,wasm} - not a flashable
-    # .bin/.uf2/.hex - and it needs the Emscripten SDK; board_level=extra keeps
-    # it out of generate_ci_matrix.py.
-    uses: ./.github/workflows/build_portduino_wasm.yml
-
   docker:
-    if: github.event_name != 'schedule' && github.event.inputs.nightly != 'true' && !contains(github.ref_name, 'event/')
     permissions: # Needed for pushing to GHCR.
       contents: read
       packages: write
@@ -218,8 +153,15 @@ jobs:
       fail-fast: false
       matrix:
         distro: [debian, alpine]
-        platform: [linux/arm64]
-        pio_env: [native-tft]
+        platform: [linux/amd64, linux/arm64, linux/arm/v7]
+        pio_env: [native, native-tft]
+        exclude:
+          - distro: alpine
+            platform: linux/arm/v7
+          - pio_env: native-tft
+            platform: linux/arm64
+          - pio_env: native-tft
+            platform: linux/arm/v7
     uses: ./.github/workflows/docker_build.yml
     with:
       distro: ${{ matrix.distro }}
@@ -228,32 +170,9 @@ jobs:
       pio_env: ${{ matrix.pio_env }}
       push: false
 
-  # Single, stable status check for branch protection.
-  # Always runs and passes only if every build and check that ran succeeded.
-  ci-gate:
-    # Consumed in PRs and Merge Queue
-    if: contains(fromJSON('["pull_request", "merge_group"]'), github.event_name) && !cancelled()
-    needs: [build, check]
-    runs-on: ubuntu-slim
-    steps:
-      - name: Verify build and check results
-        run: |
-          echo "build=${{ needs.build.result }} check=${{ needs.check.result }}"
-          if [[ "${{ needs.build.result }}" != "success" ]]; then
-            echo "::error::One or more firmware builds failed, were cancelled, or did not run."
-            exit 1
-          fi
-          case "${{ needs.check.result }}" in
-            success | skipped) ;;
-            *)
-              echo "::error::One or more checks failed or were cancelled (${{ needs.check.result }})."
-              exit 1
-              ;;
-          esac
-
   gather-artifacts:
-    # Only run on Release (workflow_dispatch) and Nightly (schedule) runs, not on PRs or merge_group runs.
-    if: github.repository_owner == 'meshtastic' && contains(fromJSON('["workflow_dispatch", "schedule"]'), github.event_name)
+    # trunk-ignore(checkov/CKV2_GHA_1)
+    if: github.repository == 'meshtastic/firmware'
     strategy:
       fail-fast: false
       matrix:
@@ -270,7 +189,7 @@ jobs:
     needs: [version, build]
     steps:
       - name: Checkout code
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
 
       - uses: actions/download-artifact@v8
         with:
@@ -326,161 +245,53 @@ jobs:
           path: ./*.elf
           retention-days: 30
 
-  firmware-size-report:
-    if: github.repository_owner == 'meshtastic' && github.event_name != 'schedule' && github.event.inputs.nightly != 'true'
+  shame:
+    if: github.repository == 'meshtastic/firmware'
     continue-on-error: true
-    permissions:
-      contents: read
-      actions: read
     runs-on: ubuntu-latest
     needs: [build]
     steps:
-      - uses: actions/checkout@v7
-
-      - name: Download current manifests
+      - uses: actions/checkout@v6
+        if: github.event_name == 'pull_request'
+        with:
+          filter: blob:none # means we download all the git history but none of the commit (except ones with checkout like the head)
+          fetch-depth: 0
+      - name: Download the current manifests
         uses: actions/download-artifact@v8
         with:
-          path: ./manifests/
+          path: ./manifests-new/
           pattern: manifest-*
           merge-multiple: true
-
-      - name: Collect current firmware sizes
-        run: python3 bin/collect_sizes.py ./manifests/ ./current-sizes.json
-
-      - name: Upload size report artifact
+      - name: Upload combined manifests for later commit and global stats crunching.
         uses: actions/upload-artifact@v7
+        id: upload-manifest
         with:
-          name: firmware-sizes-${{ github.sha }}
+          name: manifests-${{ github.sha }}
           overwrite: true
-          path: ./current-sizes.json
-          retention-days: 90
-
-      - name: Download baseline sizes from develop
+          path: manifests-new/*.mt.json
+      - name: Find the merge base
         if: github.event_name == 'pull_request'
-        continue-on-error: true
-        id: baseline-develop
+        run: echo "MERGE_BASE=$(git merge-base "origin/$base" "$head")" >> $GITHUB_ENV
         env:
-          GH_TOKEN: ${{ github.token }}
-        run: |
-          RUN_ID=$(gh run list -R "${{ github.repository }}" \
-            --workflow CI --branch develop --status success \
-            --limit 1 --json databaseId --jq '.[0].databaseId // empty')
-          if [ -n "$RUN_ID" ]; then
-            ARTIFACT_NAME=$(gh api "repos/${{ github.repository }}/actions/runs/${RUN_ID}/artifacts" \
-              --jq '.artifacts[] | select(.name | startswith("firmware-sizes-")) | select(.expired == false) | .name' | head -1)
-            if [ -n "$ARTIFACT_NAME" ]; then
-              gh run download "$RUN_ID" -R "${{ github.repository }}" \
-                --name "$ARTIFACT_NAME" --dir ./baseline-develop/
-              cp "./baseline-develop/current-sizes.json" ./develop-sizes.json
-              echo "found=true" >> "$GITHUB_OUTPUT"
-            else
-              echo "found=false" >> "$GITHUB_OUTPUT"
-            fi
-          else
-            echo "found=false" >> "$GITHUB_OUTPUT"
-          fi
-
-      - name: Download baseline sizes from master
-        if: github.event_name == 'pull_request'
-        continue-on-error: true
-        id: baseline-master
-        env:
-          GH_TOKEN: ${{ github.token }}
-        run: |
-          RUN_ID=$(gh run list -R "${{ github.repository }}" \
-            --workflow CI --branch master --status success \
-            --limit 1 --json databaseId --jq '.[0].databaseId // empty')
-          if [ -n "$RUN_ID" ]; then
-            ARTIFACT_NAME=$(gh api "repos/${{ github.repository }}/actions/runs/${RUN_ID}/artifacts" \
-              --jq '.artifacts[] | select(.name | startswith("firmware-sizes-")) | select(.expired == false) | .name' | head -1)
-            if [ -n "$ARTIFACT_NAME" ]; then
-              gh run download "$RUN_ID" -R "${{ github.repository }}" \
-                --name "$ARTIFACT_NAME" --dir ./baseline-master/
-              cp "./baseline-master/current-sizes.json" ./master-sizes.json
-              echo "found=true" >> "$GITHUB_OUTPUT"
-            else
-              echo "found=false" >> "$GITHUB_OUTPUT"
-            fi
-          else
-            echo "found=false" >> "$GITHUB_OUTPUT"
-          fi
-
-      - name: Generate size comparison report
-        if: github.event_name == 'pull_request'
-        id: report
-        run: |
-          ARGS="./current-sizes.json --budgets bin/ram_budgets.json"
-          if [ -f ./develop-sizes.json ]; then
-            ARGS="$ARGS --baseline develop:./develop-sizes.json"
-          fi
-          if [ -f ./master-sizes.json ]; then
-            ARGS="$ARGS --baseline master:./master-sizes.json"
-          fi
-          REPORT=$(python3 bin/size_report.py $ARGS)
-          if [ -z "$REPORT" ]; then
-            echo "has_report=false" >> "$GITHUB_OUTPUT"
-          else
-            echo "has_report=true" >> "$GITHUB_OUTPUT"
-            {
-              echo '<!-- firmware-size-report -->'
-              echo '# Firmware Size Report'
-              echo ''
-              echo "$REPORT"
-              echo ''
-              echo '---'
-              echo "*Updated for ${{ github.sha }}*"
-            } > ./size-report.md
-            cat ./size-report.md >> "$GITHUB_STEP_SUMMARY"
-          fi
-
-      - name: Save PR number
-        if: github.event_name == 'pull_request' && steps.report.outputs.has_report == 'true'
-        run: echo "${{ github.event.pull_request.number }}" > ./pr-number.txt
-
-      - name: Upload size report
-        if: github.event_name == 'pull_request' && steps.report.outputs.has_report == 'true'
-        uses: actions/upload-artifact@v7
-        with:
-          name: size-report
-          path: |
-            ./size-report.md
-            ./pr-number.txt
-          retention-days: 5
-
-  # RAM/flash guardrails: fails CI when an env listed in bin/ram_budgets.json
-  # exceeds its static RAM (.data+.bss) or flash budget. Kept separate from
-  # firmware-size-report, which is informational and continue-on-error.
-  size-budget-gate:
-    if: github.event_name != 'schedule' && github.event.inputs.nightly != 'true'
-    permissions:
-      contents: read
-      actions: read
-    runs-on: ubuntu-latest
-    needs: [build]
-    steps:
-      - uses: actions/checkout@v7
-
-      # No continue-on-error / empty-dir fallback: the gate must fail closed when
-      # the data it enforces on cannot be fetched (size_report.py additionally
-      # fails on missing budgeted envs under --enforce-budgets).
-      - name: Download current manifests
-        uses: actions/download-artifact@v8
-        with:
-          path: ./manifests/
-          pattern: manifest-*
-          merge-multiple: true
-
-      - name: Collect current firmware sizes
-        run: python3 bin/collect_sizes.py ./manifests/ ./current-sizes.json
-
-      - name: Enforce RAM/flash budgets
-        run: python3 bin/size_report.py ./current-sizes.json --budgets bin/ram_budgets.json --enforce-budgets
+          base: ${{ github.base_ref }}
+          head: ${{ github.sha }}
+      # Currently broken (for-loop through EVERY artifact -- rate limiting)
+      # - name: Download the old manifests
+      #   if: github.event_name == 'pull_request'
+      #   run: gh run download -R "$repo" --name "manifests-$merge_base" --dir manifest-old/
+      #   env:
+      #     GH_TOKEN: ${{ github.token }}
+      #     merge_base: ${{ env.MERGE_BASE }}
+      #     repo: ${{ github.repository }}
+      # - name: Do scan and post comment
+      #   if: github.event_name == 'pull_request'
+      #   run: python3 bin/shame.py ${{ github.event.pull_request.number }} manifests-old/ manifests-new/
 
   release-artifacts:
     permissions: # Needed for 'gh release upload'.
       contents: write
     runs-on: ubuntu-latest
-    if: github.repository_owner == 'meshtastic' && github.event_name == 'workflow_dispatch' && github.event.inputs.nightly != 'true'
+    if: ${{ github.event_name == 'workflow_dispatch' && github.repository == 'meshtastic/firmware' }}
     outputs:
       upload_url: ${{ steps.create_release.outputs.upload_url }}
     needs:
@@ -492,7 +303,7 @@ jobs:
       # - MacOS
     steps:
       - name: Checkout
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           fetch-depth: 0
 
@@ -522,7 +333,6 @@ jobs:
           prerelease: true
           name: Meshtastic Firmware ${{ needs.version.outputs.long }} Alpha
           tag_name: v${{ needs.version.outputs.long }}
-          target_commitish: ${{ github.sha }}
           body: ${{ steps.release_notes.outputs.notes }}
 
       - name: Download source deb
@@ -565,7 +375,7 @@ jobs:
 
       - name: Add sources to GitHub Release
         # Only run when targeting master branch with workflow_dispatch
-        if: github.ref_name == 'master'
+        if: ${{ github.ref_name == 'master' }}
         run: |
           gh release upload v${{ needs.version.outputs.long }} ./firmware-${{ needs.version.outputs.long }}.json
           gh release upload v${{ needs.version.outputs.long }} ./output/meshtasticd-${{ needs.version.outputs.deb }}-src.zip
@@ -589,11 +399,11 @@ jobs:
           - rp2350
           - stm32
     runs-on: ubuntu-latest
-    if: github.repository_owner == 'meshtastic' && github.event_name == 'workflow_dispatch' && github.event.inputs.nightly != 'true'
+    if: ${{ github.event_name == 'workflow_dispatch' && github.repository == 'meshtastic/firmware'}}
     needs: [release-artifacts, version]
     steps:
       - name: Checkout
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
 
       - name: Setup Python
         uses: actions/setup-python@v6
@@ -632,7 +442,7 @@ jobs:
 
       - name: Add bins and debug elfs to GitHub Release
         # Only run when targeting master branch with workflow_dispatch
-        if: github.ref_name == 'master'
+        if: ${{ github.ref_name == 'master' }}
         run: |
           gh release upload v${{ needs.version.outputs.long }} ./firmware-${{matrix.arch}}-${{ needs.version.outputs.long }}.zip
           gh release upload v${{ needs.version.outputs.long }} ./debug-elfs-${{matrix.arch}}-${{ needs.version.outputs.long }}.zip
@@ -641,14 +451,14 @@ jobs:
 
   publish-firmware:
     runs-on: ubuntu-24.04
-    if: github.repository_owner == 'meshtastic' && github.event_name == 'workflow_dispatch' && github.event.inputs.nightly != 'true'
+    if: ${{ github.event_name == 'workflow_dispatch' }}
     needs: [release-firmware, version]
     env:
       targets: |-
         esp32,esp32s3,esp32c3,esp32c6,nrf52840,rp2040,rp2350,stm32
     steps:
       - name: Checkout
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           fetch-depth: 0
 
@@ -693,78 +503,3 @@ jobs:
           user_email: github-actions[bot]@users.noreply.github.com
           commit_message: ${{ needs.version.outputs.long }}
           enable_jekyll: true
-
-  # Nightly publish: refresh the single, stable firmware-nightly/ folder on
-  # meshtastic.github.io with the current develop build. Runs on the cron schedule
-  # (or a manual nightly=true dispatch) and never creates a GitHub release. The
-  # folder's release_notes.md is maintained by hand and deliberately left untouched.
-  publish-nightly:
-    runs-on: ubuntu-24.04
-    if: github.repository_owner == 'meshtastic' && (github.event_name == 'schedule' || github.event.inputs.nightly == 'true')
-    needs: [setup, version, gather-artifacts]
-    env:
-      targets: |-
-        esp32,esp32s3,esp32c3,esp32c6,nrf52840,rp2040,rp2350,stm32
-    steps:
-      - name: Get firmware artifacts
-        uses: actions/download-artifact@v8
-        with:
-          pattern: firmware-{${{ env.targets }}}-${{ needs.version.outputs.long }}
-          merge-multiple: true
-          path: ./stage
-
-      - name: Generate Release manifest
-        run: |
-          jq -n --arg ver "${{ needs.version.outputs.long }}" --argjson targets ${{ toJson(needs.setup.outputs.all) }} '{
-            "version": $ver,
-            "targets": $targets
-          }' > ./stage/firmware-${{ needs.version.outputs.long }}.json
-
-      - name: Generate nightly pointer
-        run: |
-          jq -n \
-            --arg ver "${{ needs.version.outputs.long }}" \
-            --arg sha "${{ github.sha }}" \
-            '{version: $ver, id: ("v" + $ver), title: ("Meshtastic Firmware " + $ver + " Nightly"), commit: $sha}' \
-            > ./stage/index.json
-
-      - name: Preserve manually-maintained release notes
-        # firmware-nightly/release_notes.md is edited by hand. Carry the current
-        # copy into ./stage so the keep_files:false publish (which refreshes the
-        # folder and clears stale nightly binaries) does not drop it. Seed a
-        # placeholder on the first run (404); fail closed on any other error so a
-        # transient fetch failure never clobbers the notes.
-        run: |
-          set -euo pipefail
-          url=https://raw.githubusercontent.com/meshtastic/meshtastic.github.io/master/firmware-nightly/release_notes.md
-          code=$(curl -sSL -o ./stage/release_notes.md -w '%{http_code}' --retry 5 --retry-all-errors "$url" || echo 000)
-          if [ "$code" = "200" ]; then
-            echo "Preserved existing release_notes.md"
-          elif [ "$code" = "404" ]; then
-            echo "No existing release_notes.md; seeding placeholder"
-            printf '# Nightly (develop)\n\nAutomated nightly build from the `develop` branch. Edit these notes by hand.\n' > ./stage/release_notes.md
-          else
-            echo "Unexpected HTTP $code fetching release_notes.md; refusing to publish to avoid clobbering manual notes"
-            exit 1
-          fi
-
-      # For diagnostics
-      - name: Display structure of files to publish
-        run: ls -lR ./stage
-
-      - name: Publish nightly to meshtastic.github.io
-        uses: peaceiris/actions-gh-pages@v4
-        with:
-          deploy_key: ${{ secrets.DIST_PAGES_DEPLOY_KEY }}
-          external_repository: meshtastic/meshtastic.github.io
-          publish_branch: master
-          publish_dir: ./stage
-          # keep_files:false is scoped to destination_dir, so this refreshes only
-          # firmware-nightly/ (clearing stale nightly binaries) while sibling
-          # release folders stay untouched; release_notes.md is carried in above.
-          destination_dir: firmware-nightly
-          keep_files: false
-          user_name: github-actions[bot]
-          user_email: github-actions[bot]@users.noreply.github.com
-          commit_message: Nightly ${{ needs.version.outputs.long }}
-          enable_jekyll: true

.github/workflows/models_issue_triage.yml

@@ -0,0 +1,213 @@
+name: Issue Triage (Models)
+
+on:
+  issues:
+    types: [opened]
+
+permissions:
+  issues: write
+  models: read
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.issue.number }}
+  cancel-in-progress: true
+
+jobs:
+  triage:
+    if: ${{ github.repository == 'meshtastic/firmware' && github.event.issue.user.type != 'Bot' }}
+    runs-on: ubuntu-latest
+    steps:
+      # ─────────────────────────────────────────────────────────────────────────
+      # Step 1: Quality check (spam/AI-slop detection) - runs first, exits early if spam
+      # ─────────────────────────────────────────────────────────────────────────
+      - name: Detect spam or low-quality content
+        uses: actions/ai-inference@v2
+        id: quality
+        continue-on-error: true
+        with:
+          max-tokens: 20
+          prompt: |
+            Is this GitHub issue spam, AI-generated slop, or low quality?
+
+            Title: ${{ github.event.issue.title }}
+            Body: ${{ github.event.issue.body }}
+
+            Respond with exactly one of: spam, ai-generated, needs-review, ok
+          system-prompt: You detect spam and low-quality contributions. Be conservative - only flag obvious spam or AI slop.
+          model: openai/gpt-4o-mini
+
+      - name: Apply quality label if needed
+        if: steps.quality.outputs.response != '' && steps.quality.outputs.response != 'ok'
+        uses: actions/github-script@v9
+        env:
+          QUALITY_LABEL: ${{ steps.quality.outputs.response }}
+        with:
+          script: |
+            const label = (process.env.QUALITY_LABEL || '').trim().toLowerCase();
+            const labelMeta = {
+              'spam': { color: 'd73a4a', description: 'Possible spam' },
+              'ai-generated': { color: 'fbca04', description: 'Possible AI-generated low-quality content' },
+              'needs-review': { color: 'f9d0c4', description: 'Needs human review' },
+            };
+            const meta = labelMeta[label];
+            if (!meta) return;
+
+            // Ensure label exists
+            try {
+              await github.rest.issues.getLabel({ owner: context.repo.owner, repo: context.repo.repo, name: label });
+            } catch (e) {
+              if (e.status !== 404) throw e;
+              await github.rest.issues.createLabel({ owner: context.repo.owner, repo: context.repo.repo, name: label, color: meta.color, description: meta.description });
+            }
+
+            // Apply label
+            await github.rest.issues.addLabels({ owner: context.repo.owner, repo: context.repo.repo, issue_number: context.payload.issue.number, labels: [label] });
+
+            // Set output to skip remaining steps
+            core.setOutput('is_spam', 'true');
+
+      # ─────────────────────────────────────────────────────────────────────────
+      # Step 2: Duplicate detection - only if not spam
+      # ─────────────────────────────────────────────────────────────────────────
+      - name: Detect duplicate issues
+        if: steps.quality.outputs.response == 'ok' || steps.quality.outputs.response == ''
+        uses: pelikhan/action-genai-issue-dedup@bdb3b5d9451c1090ffcdf123d7447a5e7c7a2528 # v0.0.19
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+
+      # ─────────────────────────────────────────────────────────────────────────
+      # Step 3: Completeness check + auto-labeling (combined into one AI call)
+      # ─────────────────────────────────────────────────────────────────────────
+      - name: Determine if completeness check should be skipped
+        if: steps.quality.outputs.response == 'ok' || steps.quality.outputs.response == ''
+        uses: actions/github-script@v9
+        id: check-skip
+        with:
+          script: |
+            const title = (context.payload.issue.title || '').toLowerCase();
+            const labels = (context.payload.issue.labels || []).map(label => label.name);
+            const hasFeatureRequest = title.includes('feature request');
+            const hasEnhancement = labels.includes('enhancement');
+            const shouldSkip = hasFeatureRequest && hasEnhancement;
+            core.setOutput('should_skip', shouldSkip ? 'true' : 'false');
+
+      - name: Analyze issue completeness and determine labels
+        if: (steps.quality.outputs.response == 'ok' || steps.quality.outputs.response == '') && steps.check-skip.outputs.should_skip != 'true'
+        uses: actions/ai-inference@v2
+        id: analysis
+        continue-on-error: true
+        with:
+          prompt: |
+            Analyze this GitHub issue for completeness and determine if it needs labels.
+
+            IMPORTANT: Distinguish between:
+            - Device/firmware bugs (crashes, reboots, lockups, radio/GPS/display/power issues) - these need device logs
+            - Build/release/packaging issues (missing files, CI failures, download problems) - these do NOT need device logs
+            - Documentation or website issues - these do NOT need device logs
+
+            If this is a device/firmware bug, request device logs and explain how to get them:
+
+            Web Flasher logs:
+            - Go to https://flasher.meshtastic.org
+            - Connect the device via USB and click Connect
+            - Open the device console/log output, reproduce the problem, then copy/download and attach/paste the logs
+
+            Meshtastic CLI logs:
+            - Run: meshtastic --port <serial-port> --noproto
+            - Reproduce the problem, then copy/paste the terminal output
+
+            Also request key context if missing: device model/variant, firmware version, region, steps to reproduce, expected vs actual.
+
+            Respond ONLY with valid JSON (no markdown, no code fences):
+            {"complete": true, "comment": "", "label": "none"}
+            OR
+            {"complete": false, "comment": "Your helpful comment", "label": "needs-logs"}
+
+            Use "needs-logs" ONLY if this is a device/firmware bug AND no logs are attached.
+            Use "needs-info" if basic info like firmware version or steps to reproduce are missing.
+            Use "none" if the issue is complete, is a feature request, or is a build/CI/packaging issue.
+
+            Title: ${{ github.event.issue.title }}
+            Body: ${{ github.event.issue.body }}
+          system-prompt: You are a helpful assistant that triages GitHub issues. Be conservative with labels. Only request device logs for actual device/firmware bugs, not for build/release/CI issues.
+          model: openai/gpt-4o-mini
+
+      - name: Process analysis result
+        if: (steps.quality.outputs.response == 'ok' || steps.quality.outputs.response == '') && steps.check-skip.outputs.should_skip != 'true' && steps.analysis.outputs.response != ''
+        uses: actions/github-script@v9
+        id: process
+        env:
+          AI_RESPONSE: ${{ steps.analysis.outputs.response }}
+        with:
+          script: |
+            let raw = (process.env.AI_RESPONSE || '').trim();
+
+            // Strip markdown code fences if present
+            raw = raw.replace(/^```(?:json)?\s*/i, '').replace(/\s*```$/i, '').trim();
+
+            let complete = true;
+            let comment = '';
+            let label = 'none';
+
+            try {
+              const parsed = JSON.parse(raw);
+              complete = !!parsed.complete;
+              comment = (parsed.comment ?? '').toString().trim();
+              label = (parsed.label ?? 'none').toString().trim().toLowerCase();
+            } catch {
+              // If JSON parse fails, log warning and don't comment (avoid posting raw JSON)
+              console.log('Failed to parse AI response as JSON:', raw);
+              complete = true;
+              comment = '';
+              label = 'none';
+            }
+
+            // Validate label
+            const allowedLabels = new Set(['needs-logs', 'needs-info', 'none']);
+            if (!allowedLabels.has(label)) label = 'none';
+
+            // Only comment if we have a valid parsed comment (not raw JSON)
+            const shouldComment = !complete && comment.length > 0 && !comment.startsWith('{');
+            core.setOutput('should_comment', shouldComment ? 'true' : 'false');
+            core.setOutput('comment_body', comment);
+            core.setOutput('label', label);
+
+      - name: Apply triage label
+        if: steps.process.outputs.label != '' && steps.process.outputs.label != 'none'
+        uses: actions/github-script@v9
+        env:
+          LABEL_NAME: ${{ steps.process.outputs.label }}
+        with:
+          script: |
+            const label = process.env.LABEL_NAME;
+            const labelMeta = {
+              'needs-logs': { color: 'cfd3d7', description: 'Device logs requested for triage' },
+              'needs-info': { color: 'f9d0c4', description: 'More information requested for triage' },
+            };
+            const meta = labelMeta[label];
+            if (!meta) return;
+
+            // Ensure label exists
+            try {
+              await github.rest.issues.getLabel({ owner: context.repo.owner, repo: context.repo.repo, name: label });
+            } catch (e) {
+              if (e.status !== 404) throw e;
+              await github.rest.issues.createLabel({ owner: context.repo.owner, repo: context.repo.repo, name: label, color: meta.color, description: meta.description });
+            }
+
+            // Apply label
+            await github.rest.issues.addLabels({ owner: context.repo.owner, repo: context.repo.repo, issue_number: context.payload.issue.number, labels: [label] });
+
+      - name: Comment on issue
+        if: steps.process.outputs.should_comment == 'true'
+        uses: actions/github-script@v9
+        env:
+          COMMENT_BODY: ${{ steps.process.outputs.comment_body }}
+        with:
+          script: |
+            await github.rest.issues.createComment({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              issue_number: context.payload.issue.number,
+              body: process.env.COMMENT_BODY
+            });

.github/workflows/models_pr_triage.yml

@@ -0,0 +1,139 @@
+name: PR Triage (Models)
+
+on:
+  pull_request_target:
+    types: [opened]
+
+permissions:
+  pull-requests: write
+  issues: write
+  models: read
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number }}
+  cancel-in-progress: true
+
+jobs:
+  triage:
+    if: ${{ github.repository == 'meshtastic/firmware' && github.event.pull_request.user.type != 'Bot' }}
+    runs-on: ubuntu-latest
+    steps:
+      # ─────────────────────────────────────────────────────────────────────────
+      # Step 1: Check if PR already has automation/type labels (skip if so)
+      # ─────────────────────────────────────────────────────────────────────────
+      - name: Check existing labels
+        uses: actions/github-script@v9
+        id: check-labels
+        with:
+          script: |
+            const skipLabels = new Set(['automation']);
+            const typeLabels = new Set(['bugfix', 'hardware-support', 'enhancement', 'dependencies', 'submodules', 'github_actions', 'trunk', 'cleanup']);
+            const prLabels = context.payload.pull_request.labels.map(l => l.name);
+
+            const shouldSkipAll = prLabels.some(l => skipLabels.has(l));
+            const hasTypeLabel = prLabels.some(l => typeLabels.has(l));
+
+            core.setOutput('skip_all', shouldSkipAll ? 'true' : 'false');
+            core.setOutput('has_type_label', hasTypeLabel ? 'true' : 'false');
+
+      # ─────────────────────────────────────────────────────────────────────────
+      # Step 2: Quality check (spam/AI-slop detection)
+      # ─────────────────────────────────────────────────────────────────────────
+      - name: Detect spam or low-quality content
+        if: steps.check-labels.outputs.skip_all != 'true'
+        uses: actions/ai-inference@v2
+        id: quality
+        continue-on-error: true
+        with:
+          max-tokens: 20
+          prompt: |
+            Is this GitHub pull request spam, AI-generated slop, or low quality?
+
+            Title: ${{ github.event.pull_request.title }}
+            Body: ${{ github.event.pull_request.body }}
+
+            Respond with exactly one of: spam, ai-generated, needs-review, ok
+          system-prompt: You detect spam and low-quality contributions. Be conservative - only flag obvious spam or AI slop.
+          model: openai/gpt-4o-mini
+
+      - name: Apply quality label if needed
+        if: steps.check-labels.outputs.skip_all != 'true' && steps.quality.outputs.response != '' && steps.quality.outputs.response != 'ok'
+        uses: actions/github-script@v9
+        id: quality-label
+        env:
+          QUALITY_LABEL: ${{ steps.quality.outputs.response }}
+        with:
+          script: |
+            const label = (process.env.QUALITY_LABEL || '').trim().toLowerCase();
+            const labelMeta = {
+              'spam': { color: 'd73a4a', description: 'Possible spam' },
+              'ai-generated': { color: 'fbca04', description: 'Possible AI-generated low-quality content' },
+              'needs-review': { color: 'f9d0c4', description: 'Needs human review' },
+            };
+            const meta = labelMeta[label];
+            if (!meta) return;
+
+            // Ensure label exists
+            try {
+              await github.rest.issues.getLabel({ owner: context.repo.owner, repo: context.repo.repo, name: label });
+            } catch (e) {
+              if (e.status !== 404) throw e;
+              await github.rest.issues.createLabel({ owner: context.repo.owner, repo: context.repo.repo, name: label, color: meta.color, description: meta.description });
+            }
+
+            // Apply label
+            await github.rest.issues.addLabels({ owner: context.repo.owner, repo: context.repo.repo, issue_number: context.payload.pull_request.number, labels: [label] });
+
+            core.setOutput('is_spam', 'true');
+
+      # ─────────────────────────────────────────────────────────────────────────
+      # Step 3: Auto-label PR type (bugfix/hardware-support/enhancement)
+      # Only skip for spam/ai-generated; still classify needs-review PRs
+      # ─────────────────────────────────────────────────────────────────────────
+      - name: Classify PR for labeling
+        if: steps.check-labels.outputs.skip_all != 'true' && steps.check-labels.outputs.has_type_label != 'true' && steps.quality.outputs.response != 'spam' && steps.quality.outputs.response != 'ai-generated'
+        uses: actions/ai-inference@v2
+        id: classify
+        continue-on-error: true
+        with:
+          max-tokens: 30
+          prompt: |
+            Classify this pull request into exactly one category.
+
+            Return exactly one of: bugfix, hardware-support, enhancement
+
+            Use bugfix if it fixes a bug, crash, or incorrect behavior.
+            Use hardware-support if it adds or improves support for a specific hardware device/variant.
+            Use enhancement if it adds a new feature, improves performance, or refactors code.
+
+            Title: ${{ github.event.pull_request.title }}
+            Body: ${{ github.event.pull_request.body }}
+          system-prompt: You classify pull requests into categories. Be conservative and pick the most appropriate single label.
+          model: openai/gpt-4o-mini
+
+      - name: Apply type label
+        if: steps.check-labels.outputs.skip_all != 'true' && steps.check-labels.outputs.has_type_label != 'true' && steps.classify.outputs.response != ''
+        uses: actions/github-script@v9
+        env:
+          TYPE_LABEL: ${{ steps.classify.outputs.response }}
+        with:
+          script: |
+            const label = (process.env.TYPE_LABEL || '').trim().toLowerCase();
+            const labelMeta = {
+              'bugfix': { color: 'd73a4a', description: 'Bug fix' },
+              'hardware-support': { color: '0e8a16', description: 'Hardware support addition or improvement' },
+              'enhancement': { color: 'a2eeef', description: 'New feature or enhancement' },
+            };
+            const meta = labelMeta[label];
+            if (!meta) return;
+
+            // Ensure label exists
+            try {
+              await github.rest.issues.getLabel({ owner: context.repo.owner, repo: context.repo.repo, name: label });
+            } catch (e) {
+              if (e.status !== 404) throw e;
+              await github.rest.issues.createLabel({ owner: context.repo.owner, repo: context.repo.repo, name: label, color: meta.color, description: meta.description });
+            }
+
+            // Apply label
+            await github.rest.issues.addLabels({ owner: context.repo.owner, repo: context.repo.repo, issue_number: context.payload.pull_request.number, labels: [label] });

.github/workflows/nightly.yml

@@ -14,10 +14,10 @@ jobs:
 
     steps:
       - name: Checkout
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
 
       - name: Trunk Check
-        uses: trunk-io/trunk-action@v2.0.0
+        uses: trunk-io/trunk-action@v1
         with:
           trunk-token: ${{ secrets.TRUNK_TOKEN }}
 
@@ -31,9 +31,9 @@ jobs:
       pull-requests: write # For trunk to create PRs
     steps:
       - name: Checkout
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
 
       - name: Trunk Upgrade
-        uses: trunk-io/trunk-action/upgrade@v2.0.0
+        uses: trunk-io/trunk-action/upgrade@v1
         with:
-          base: develop
+          base: master

.github/workflows/package_obs.yml

@@ -33,7 +33,7 @@ jobs:
     needs: build-debian-src
     steps:
       - name: Checkout code
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           submodules: recursive
           path: meshtasticd

.github/workflows/package_pio_deps.yml

@@ -23,7 +23,7 @@ jobs:
     runs-on: ubuntu-24.04
     steps:
       - name: Checkout code
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           submodules: recursive
 

.github/workflows/package_ppa.yml

@@ -34,7 +34,7 @@ jobs:
     needs: build-debian-src
     steps:
       - name: Checkout code
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           submodules: recursive
           path: meshtasticd

.github/workflows/package_winget.yml

@@ -1,62 +0,0 @@
-name: Validate winget manifest
-
-on:
-  workflow_dispatch:
-
-permissions:
-  contents: read
-
-jobs:
-  validate-winget:
-    runs-on: windows-2025
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v7
-        with:
-          persist-credentials: false
-
-      - name: Resolve the newest release and download its MSI
-        id: release
-        shell: pwsh
-        run: |
-          $tag = gh release list --limit 1 --json tagName --jq '.[0].tagName'
-          if (-not $tag) { throw 'No releases found.' }
-          New-Item -ItemType Directory -Force -Path release/download | Out-Null
-          gh release download $tag --pattern '*.msi' --dir release/download
-          $msis = @(Get-ChildItem release/download/*.msi)
-          if ($msis.Count -eq 0) { throw "Release $tag carries no MSI asset." }
-          if ($msis.Count -gt 1) { throw "Release $tag carries $($msis.Count) MSIs; this validates one architecture." }
-          $parsed = [regex]::Match($msis[0].Name, '^meshtasticd-([0-9][0-9A-Za-z.\-]*)-(x64|arm64)\.msi$')
-          if (-not $parsed.Success) { throw "Cannot parse version and architecture out of $($msis[0].Name)." }
-          "tag=$tag", "version=$($parsed.Groups[1].Value)", "arch=$($parsed.Groups[2].Value)", "msi=$($msis[0].FullName)" | Out-File -FilePath $env:GITHUB_OUTPUT -Append
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Generate manifests for the published MSI
-        shell: pwsh
-        run: ./bin/build-winget-package.ps1 -MsiPath $env:MSI_PATH -Version $env:PKG_VERSION -Architecture $env:PKG_ARCH -ReleaseTag $env:RELEASE_TAG -Validate
-        env:
-          MSI_PATH: ${{ steps.release.outputs.msi }}
-          PKG_VERSION: ${{ steps.release.outputs.version }}
-          PKG_ARCH: ${{ steps.release.outputs.arch }}
-          RELEASE_TAG: ${{ steps.release.outputs.tag }}
-
-      - name: Verify the manifest URL resolves to the published asset
-        shell: pwsh
-        run: |
-          $installer = Get-ChildItem release/winget/manifests -Recurse -Filter '*.installer.yaml' | Select-Object -First 1
-          $url = (Select-String -Path $installer.FullName -Pattern 'InstallerUrl:\s*(\S+)').Matches[0].Groups[1].Value
-          $expected = (Select-String -Path $installer.FullName -Pattern 'InstallerSha256:\s*(\S+)').Matches[0].Groups[1].Value
-          Invoke-WebRequest -Uri $url -OutFile fetched.msi
-          $actual = (Get-FileHash fetched.msi -Algorithm SHA256).Hash
-          if ($actual -ne $expected) {
-            throw "InstallerUrl $url hashes to $actual, manifest claims $expected"
-          }
-          "URL and hash agree: $url"
-
-      - name: Upload the manifests as an artifact
-        uses: actions/upload-artifact@v7
-        with:
-          name: winget-manifests-${{ steps.release.outputs.version }}
-          overwrite: true
-          path: release/winget/manifests/

.github/workflows/pr_tests.yml

@@ -4,11 +4,10 @@ name: Tests
 on:
   workflow_dispatch:
     inputs:
-      # trunk-ignore(checkov/CKV_GHA_7): the reason input is a free-text run label, never fed into the build
       reason:
-        description: Reason for manual test run
+        description: "Reason for manual test run"
         required: false
-        default: Manual test execution
+        default: "Manual test execution"
 
 concurrency:
   group: tests-${{ github.head_ref || github.run_id }}
@@ -22,7 +21,7 @@ permissions:
 
 jobs:
   native-tests:
-    name: 🧪 Native Tests
+    name: "🧪 Native Tests"
     if: github.repository == 'meshtastic/firmware'
     uses: ./.github/workflows/test_native.yml
     permissions:
@@ -31,7 +30,7 @@ jobs:
       checks: write
 
   test-summary:
-    name: 📊 Test Results
+    name: "📊 Test Results"
     runs-on: ubuntu-latest
     needs: [native-tests]
     if: always()
@@ -41,7 +40,7 @@ jobs:
       checks: write
       pull-requests: write
     steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v6
         with:
           submodules: recursive
 

.github/workflows/release_channels.yml

@@ -23,8 +23,8 @@ jobs:
         series:
           - jammy # 22.04 LTS
           - noble # 24.04 LTS
+          - questing # 25.10
           - resolute # 26.04 LTS
-          - stonking # 26.10
     uses: ./.github/workflows/package_ppa.yml
     with:
       ppa_repo: |-
@@ -91,7 +91,7 @@ jobs:
         shell: bash
     steps:
       - name: Checkout
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           # Always use master branch for version bumps
           ref: master

.github/workflows/sec_sast_semgrep_cron.yml

@@ -21,7 +21,7 @@ jobs:
     steps:
       # step 1
       - name: clone application source code
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
 
       # step 2
       - name: full scan

.github/workflows/sec_sast_semgrep_pull.yml

@@ -13,7 +13,7 @@ jobs:
     steps:
       # step 1
       - name: clone application source code
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           fetch-depth: 0
 

.github/workflows/stale_bot.yml

@@ -17,7 +17,7 @@ jobs:
 
     steps:
       - name: Stale PR+Issues
-        uses: actions/stale@v11
+        uses: actions/stale@v10.2.0
         with:
           days-before-stale: 45
           stale-issue-message: This issue has not had any comment or update in the last month. If it is still relevant, please post update comments. If no comments are made, this issue will be closed automagically in 7 days.

.github/workflows/test_native.yml

@@ -2,154 +2,19 @@ name: Run Tests on Native platform
 
 on:
   workflow_call:
-    inputs:
-      suite_order_seed:
-        description: >-
-          Seed for shuffling the test-area order. Empty (the default) means: fixed declared order on
-          pull_request, so a contributor's PR never turns red because of an order they did not
-          choose; commit-SHA-derived elsewhere. Set a number to force that exact order anywhere -
-          that is how you replay a shuffled failure.
-        type: string
-        required: false
-        default: ""
   workflow_dispatch:
 
 permissions: {}
 
 env:
-  # Only pushes to the default branch (develop) populate the cache; PR / merge_group runs
-  # restore it but never save, so they stop filling up the repo's Actions cache storage.
-  SAVE_CACHE: ${{ github.event_name == 'push' && github.ref_name == github.event.repository.default_branch }}
   LCOV_CAPTURE_FLAGS: --quiet --capture --include "${PWD}/src/*" --exclude '*/src/mesh/generated/*' --directory .pio/build/coverage/src --base-directory "${PWD}"
 
 jobs:
-  # Tripwire against the native suite set shrinking by accident. `platformio test` discovers and
-  # runs whatever test_* directories exist, and bin/run-tests.sh derives its expected count from
-  # the same walk - so a suite directory lost in a bad rebase or an overzealous cleanup just means
-  # fewer suites run, and every remaining check stays green. Compare the test_* directory list
-  # against the PR's merge base and fail when a suite vanished without the PR saying so: a removed
-  # suite's name must appear in the PR title, the PR body, or a commit message in the PR's range.
-  # A deliberate removal satisfies that by stating what it removes; an accidental loss cannot.
-  # Only pull_request runs have a base to compare against (and PRs are where accidents arrive);
-  # every other event skips. No job depends on this one: a skipped job would skip its dependents,
-  # and the expensive jobs should not wait on a full-history clone.
-  suite-shrinkage-check:
-    name: Native Suite Shrinkage
-    if: github.event_name == 'pull_request'
-    runs-on: ubuntu-slim
-    permissions:
-      contents: read
-    steps:
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7
-        with:
-          persist-credentials: false
-          # Full history: the merge base must be computed, not guessed from a possibly stale
-          # event payload, and the acknowledgment scan reads every commit message in the range.
-          fetch-depth: 0
-
-      - name: Fail if a test_* suite vanished unacknowledged
-        shell: bash
-        # PR title/body are attacker-controlled text; they reach the script through env: only,
-        # never spliced into the shell source (same rule as the suite-order seed below).
-        env:
-          BASE_REF: ${{ github.base_ref }}
-          PR_TITLE: ${{ github.event.pull_request.title }}
-          PR_BODY: ${{ github.event.pull_request.body }}
-        run: |
-          set -euo pipefail
-          git fetch --quiet origin "$BASE_REF"
-          base=$(git merge-base FETCH_HEAD HEAD)
-          # Same canonical set every other consumer derives: directories named test_* directly
-          # under test/, read from the git trees so the comparison is exact at both endpoints.
-          list_suites() { git ls-tree -d --name-only "$1" test/ | sed 's#^test/##' | grep '^test_' | sort; }
-          removed=$(comm -23 <(list_suites "$base") <(list_suites HEAD))
-          if [[ -z $removed ]]; then
-            echo "No suite removed: $(list_suites HEAD | wc -l) test_* directories, none lost since merge base ${base:0:8}."
-            exit 0
-          fi
-          messages=$(git log --format=%B "$base..HEAD")
-          fail=0
-          while IFS= read -r suite; do
-            if printf '%s\n%s\n%s\n' "$PR_TITLE" "$PR_BODY" "$messages" | grep -qF "$suite"; then
-              echo "Removed suite $suite is named in the PR title/body or a commit message - acknowledged."
-            else
-              echo "::error title=Native suite vanished::test/$suite exists on the merge base but is gone from this PR, and nothing in the PR title, body, or commit messages mentions it. If the removal is deliberate, name $suite in the PR description or a commit message; if not, restore the directory - platformio test would silently run without it."
-              fail=1
-            fi
-          done <<<"$removed"
-          exit $fail
-
-  # Reject naive deadline comparisons against the 32-bit uptime clocks. `millis() > deadline` and
-  # `deadline < millis()` invert while the deadline sits on the far side of the 32-bit wrap: the
-  # action fires immediately, or blocks for about the interval it should have waited. The correct
-  # forms are
-  # Throttle::isWithinTimespanMs / hasElapsed (elapsed since a stored event) and
-  # Throttle::deadlinePassed (an absolute deadline). See .github/copilot-instructions.md.
-  millis-deadline-check:
-    # Name is load-bearing: upstream branch protection matches the check by name. Widen the guard,
-    # not this string.
-    name: Naive millis() Deadline Compare
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-    steps:
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7
-        with:
-          persist-credentials: false
-
-      - name: Reject 32-bit uptime clocks used directly in a deadline comparison
-        shell: bash
-        run: |
-          set -euo pipefail
-          allowlist=".github/millis-deadline-allowlist.txt"
-
-          # Flag millis() or its Time::getMillis() wrapper directly adjacent to a comparison
-          # operator, in either order. The correct idioms subtract first, so they are not matched.
-          #
-          # Line comments are stripped before matching, so prose may name the broken idiom (this
-          # guard's own documentation does). Block comments are not stripped; keep `millis() >` out
-          # of /* */ blocks. mawk-compatible - ubuntu-latest has no gawk.
-          find src -type f \( -name '*.cpp' -o -name '*.h' -o -name '*.hpp' -o -name '*.ino' \) \
-               ! -path 'src/mesh/generated/*' -print0 |
-            xargs -0 awk '
-              {
-                line = $0
-                sub(/\/\/.*/, "", line)
-                if (line ~ /((millis|getMillis)\(\)[ \t]*[<>]=?)|([<>]=?[ \t]*(millis|getMillis)\(\))/) {
-                  code = line
-                  sub(/^[ \t]+/, "", code); sub(/[ \t]+$/, "", code)
-                  printf "%s\t%s\t%s\n", FILENAME, FNR, code
-                }
-              }' > /tmp/millis-hits.tsv
-
-          # Allowlisted entries are keyed on file + exact source text, deliberately without a line
-          # number, so unrelated edits above them do not invalidate the entry.
-          : > /tmp/millis-allowed.tsv
-          if [[ -f $allowlist ]]; then
-            grep -vE '^[[:space:]]*(#|$)' "$allowlist" > /tmp/millis-allowed.tsv || true
-          fi
-
-          violations=0
-          while IFS=$'\t' read -r file line code; do
-            [[ -n ${file:-} ]] || continue
-            if grep -qxF "$(printf '%s\t%s' "$file" "$code")" /tmp/millis-allowed.tsv; then
-              continue
-            fi
-            echo "$file:$line: $code"
-            violations=$((violations + 1))
-          done < /tmp/millis-hits.tsv
-
-          if [[ $violations -gt 0 ]]; then
-            echo "::error title=Naive uptime deadline compare::$violations line(s) compare a 32-bit uptime clock directly, which inverts while the deadline is on the far side of the 32-bit wrap - the action fires immediately, or blocks for about the interval it should have waited. Use Throttle::deadlinePassed(deadline) for a stored absolute deadline, or Throttle::hasElapsed(lastEvent, intervalMs) for an interval. If a match genuinely is not a deadline test (an uptime threshold, say), add it to $allowlist with a reason."
-            exit 1
-          fi
-          echo "No naive 32-bit uptime deadline comparisons in src/ (allowlist: $(wc -l < /tmp/millis-allowed.tsv) entr(y/ies))."
-
   simulator-tests:
     name: Native Simulator Tests
-    runs-on: ubuntu-24.04-arm
+    runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7
+      - uses: actions/checkout@v6
         with:
           submodules: recursive
 
@@ -160,26 +25,10 @@ jobs:
       - name: Install simulator dependencies
         run: pip install -U dotmap
 
-      - name: Restore PlatformIO cache
-        id: pio-cache
-        uses: actions/cache/restore@v6
-        with:
-          path: ~/.platformio/.cache
-          key: pio-simulator-tests-${{ hashFiles('platformio.ini', 'variants/native/portduino.ini', 'variants/native/portduino/platformio.ini') }}
-          restore-keys: |
-            pio-simulator-tests-
-
       # We now run integration test before other build steps (to quickly see runtime failures)
       - name: Build for native/coverage
         run: platformio run -e coverage
 
-      - name: Save PlatformIO cache
-        if: env.SAVE_CACHE == 'true' && steps.pio-cache.outputs.cache-hit != 'true'
-        uses: actions/cache/save@v6
-        with:
-          path: ~/.platformio/.cache
-          key: pio-simulator-tests-${{ hashFiles('platformio.ini', 'variants/native/portduino.ini', 'variants/native/portduino/platformio.ini') }}
-
       - name: Capture initial coverage information
         shell: bash
         run: |
@@ -187,49 +36,14 @@ jobs:
           lcov ${{ env.LCOV_CAPTURE_FLAGS }} --initial --output-file coverage_base.info
           sed -i -e "s#${PWD}#.#" coverage_base.info # Make paths relative.
 
-      - name: Config check tests
-        # Drives the same binary against test/fixtures/portduino-config: asserts that
-        # `--check` reports each planted fault, and that a normal run still refuses the
-        # configs it should. Runs before the simulator test because it is seconds long
-        # and a failure here explains a lot of downstream weirdness.
-        timeout-minutes: 5
-        run: ./bin/test-config-check.sh .pio/build/coverage/meshtasticd
-
-      - name: Shared-state checker self-test
-        # Fixtures that write nothing / exactly what they declare / something undeclared /
-        # a declared write they never make, asserting CLEAN / CLEAN / DIRTY / MISSING. A
-        # checker that has silently stopped matching looks identical to a clean codebase.
-        timeout-minutes: 5
-        run: ./bin/test-state-check.sh
-
       - name: Integration test
-        # Cap the whole step: if the simulator ever fails to exit (e.g. the
-        # exit_simulator admin path regresses again) the job must fail fast,
-        # not run to GitHub's 6-hour limit.
-        timeout-minutes: 5
         run: |
           .pio/build/coverage/meshtasticd -s &
           PID=$!
-          trap 'kill "$PID" 2>/dev/null || true' EXIT
           timeout 20 bash -c "until ls -al /proc/$PID/fd | grep socket; do sleep 1; done"
           echo "Simulator started, launching python test..."
           python3 -c 'from meshtastic.test import testSimulator; testSimulator()'
-          # The Python harness sends exit_simulator and exits; the simulator is
-          # expected to terminate on its own. Give it a moment, then verify.
-          # If it is still alive the exit handshake is broken - fail loudly and
-          # do NOT fall through to `wait`, which would otherwise block until the
-          # job's hard timeout.
-          for i in $(seq 1 10); do
-            kill -0 "$PID" 2>/dev/null || break
-            sleep 1
-          done
-          if kill -0 "$PID" 2>/dev/null; then
-            echo "::error title=Simulator did not exit::meshtasticd ignored exit_simulator and is still running after the integration test. The exit_simulator admin path is broken (see AdminModule::handleReceivedProtobuf, ARCH_PORTDUINO bypass). Killing it to avoid a 6-hour CI overrun."
-            kill -9 "$PID" 2>/dev/null || true
-            wait "$PID" 2>/dev/null || true
-            exit 1
-          fi
-          wait "$PID" 2>/dev/null || true
+          wait
 
       - name: Capture coverage information
         if: always() # run this step even if previous step failed
@@ -252,9 +66,9 @@ jobs:
 
   platformio-tests:
     name: Native PlatformIO Tests
-    runs-on: ubuntu-24.04-arm
+    runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7
+      - uses: actions/checkout@v6
         with:
           submodules: recursive
 
@@ -271,195 +85,8 @@ jobs:
       - name: Disable BUILD_EPOCH
         run: sed -i 's/-DBUILD_EPOCH=$UNIX_TIME/#-DBUILD_EPOCH=$UNIX_TIME/' platformio.ini
 
-      - name: Restore PlatformIO cache
-        id: pio-cache
-        uses: actions/cache/restore@v6
-        with:
-          path: ~/.platformio/.cache
-          key: pio-coverage-tests-${{ hashFiles('platformio.ini', 'variants/native/portduino.ini', 'variants/native/portduino/platformio.ini') }}
-          restore-keys: |
-            pio-coverage-tests-
-
-      - name: Warm the shared test build
-        # Compiles src + every test program once so no single area absorbs the whole src build in
-        # its reported duration; gcov then accumulates counts into this shared
-        # .pio/build/coverage/src as the areas run. NOT a substitute for building in the run step:
-        # PlatformIO links every test program to the one .pio/build/coverage/meshtasticd path, so a
-        # --without-building run executes whichever suite was linked last under every suite's name.
-        run: platformio test -e coverage --without-testing
-
-      - name: Save PlatformIO cache
-        if: env.SAVE_CACHE == 'true' && steps.pio-cache.outputs.cache-hit != 'true'
-        uses: actions/cache/save@v6
-        with:
-          path: ~/.platformio/.cache
-          key: pio-coverage-tests-${{ hashFiles('platformio.ini', 'variants/native/portduino.ini', 'variants/native/portduino/platformio.ini') }}
-
-      - name: Run tests one area at a time
-        shell: bash
-        # Both values reach the script through env: rather than ${{ }} inside run:, so nothing from
-        # the event payload is ever spliced into the shell text.
-        env:
-          SUITE_ORDER_SEED: ${{ inputs.suite_order_seed }}
-          EVENT_NAME: ${{ github.event_name }}
-        run: |
-          set -uo pipefail
-          # One runner, no matrix, no concurrency. Group the test_* suites by area and run each
-          # area sequentially, reusing the single build above (--without-building). Each area gets
-          # its own JUnit report and its own collapsible log, so a failure lands in a small named
-          # section instead of being buried past the log limit. Sequential runs share one build
-          # dir, so gcov coverage accumulates and the single capture in the next step has the union.
-
-          # Ordered area rules "name:ERE"; first match wins. Anything unmatched falls to "misc", so
-          # a newly added suite always runs even before it is placed. Add a suite to an area by
-          # extending that area's regex; add a new area by inserting a rule line.
-          area_rules=(
-            "admin:^test_(admin|pki)_"
-            "crypto:^test_(crypto|packet_signing)$"
-            "routing:^test_(mesh|nexthop|traceroute|hop|traffic|nodedb|warm)_"
-            "position:^test_position_"
-            "fuzz:^test_fuzz_"
-            "packets:^test_(packet|transmit|meshpacket)_"
-            "io:^test_(serial|stream|xmodem|http|mqtt)"
-          )
-
-          mapfile -t suites < <(find test -maxdepth 1 -type d -name 'test_*' -printf '%f\n' | sort)
-          declare -A group
-          for s in "${suites[@]}"; do
-            a="misc"
-            for rule in "${area_rules[@]}"; do
-              if [[ "$s" =~ ${rule#*:} ]]; then a="${rule%%:*}"; break; fi
-            done
-            group[$a]="${group[$a]:-} -f $s"
-          done
-
-          run_order=()
-          for rule in "${area_rules[@]}"; do run_order+=("${rule%%:*}"); done
-          run_order+=("misc")
-
-          # Area order. The rule order above is an accident of how the areas were written, and
-          # running it fixed forever means order dependence between areas is never observed - but
-          # randomising it on a contributor's PR would turn their run red for an order they did not
-          # choose, which is how a randomisation gets reverted instead of the coupling fixed.
-          #
-          # So: pull_request keeps the fixed declared order. Everywhere else (push, schedule) the
-          # order is shuffled, seeded from the commit SHA - deterministic per commit, replayable,
-          # attributable, and it never blocks someone else's PR. An explicit seed input overrides
-          # both, which is how you replay a specific failing order anywhere.
-          #
-          # Intra-area order stays PlatformIO's: filters select suites, they do not order them
-          # (list_test_names() walks test/ with os.walk()), so controlling it needs one invocation
-          # per suite. bin/run-tests.sh --shuffle does exactly that locally.
-          seed_input="${SUITE_ORDER_SEED:-}"
-          if [ -n "$seed_input" ]; then
-            seed="$seed_input"
-            echo "area order: shuffled with explicitly supplied seed $seed"
-          elif [ "${EVENT_NAME:-}" = "pull_request" ]; then
-            seed=""
-            echo "area order: fixed declared order (pull_request) - ${run_order[*]}"
-            echo "  to exercise a different order, re-run this workflow with a suite_order_seed input"
-          else
-            seed=$((16#${GITHUB_SHA:0:8}))
-            echo "area order: shuffled with seed $seed (from ${GITHUB_SHA:0:8})"
-          fi
-
-          if [ -n "$seed" ]; then
-            # Same shuffle_suites() bin/run-tests.sh uses, so the replay hint below is true by
-            # construction rather than by two copies happening to agree.
-            source bin/lib/shuffle.sh
-            mapfile -t run_order < <(shuffle_suites "$seed" "${run_order[@]}")
-            echo "area order: ${run_order[*]}"
-            echo "  replay locally: ./bin/run-tests.sh --shuffle --seed $seed"
-          fi
-
-          fail=0
-          for a in "${run_order[@]}"; do
-            [ -n "${group[$a]:-}" ] || continue
-            echo "::group::area $a (${group[$a]# })"
-            # Capture platformio's real exit status (not grep's) via a log file, then show the log
-            # with the noisy per-variant SKIPPED rows filtered out.
-            if ! platformio test -e coverage -v ${group[$a]# } \
-                 --junit-output-path "testreport-$a.xml" > "area-$a.log" 2>&1; then
-              fail=1
-              echo "::error::area $a had test failures"
-            fi
-            # Suites outside this area are reported SKIPPED by design (PlatformIO lists every suite
-            # in the env and marks the unselected ones finished), so those rows are noise here. The
-            # attribution check below is what catches a suite that was selected and did not run.
-            grep -v "[[:space:]]SKIPPED$" "area-$a.log" || true
-            # Per area, so a mismatch names the area it happened in rather than the whole run.
-            if ! ./bin/check-test-attribution.py --label "area $a" \
-                 --expect "${group[$a]# }" "testreport-$a.xml"; then
-              fail=1
-              echo "::error::area $a ran suites that did not match their own test binaries"
-            fi
-            echo "::endgroup::"
-          done
-          exit $fail
-
-      - name: Merge per-area reports into testreport.xml
-        # Preserve the single-file JUnit contract that downstream consumers rely on
-        # (pr_tests.yml's summary and generate-reports' Test Report both read testreport.xml).
-        # The per-area split is only for readable logs; the report stays consolidated.
-        if: always() # run even when a chunk failed, so the report captures the failures
-        shell: bash
-        run: |
-          python3 - <<'PY'
-          import glob, xml.etree.ElementTree as ET
-          out = ET.Element('testsuites')
-          for f in sorted(glob.glob('testreport-*.xml')):
-              try:
-                  root = ET.parse(f).getroot()
-              except ET.ParseError:
-                  continue
-              # PlatformIO writes a <testsuites> root; fold in a bare <testsuite> too, just in case.
-              out.extend(root.findall('testsuite') if root.tag == 'testsuites' else [root])
-          ET.ElementTree(out).write('testreport.xml', encoding='utf-8', xml_declaration=True)
-          PY
-
-      - name: Verify every suite ran its own tests
-        # Whole-run gate over the merged report: every test_* directory must appear with at least
-        # one test case, and every case must come from the suite that reported it. The per-area
-        # check above cannot see an area that never executed - this can.
-        if: always() # a suite going missing is the finding; do not hide it behind an earlier failure
-        shell: bash
-        run: |
-          set -euo pipefail
-          mapfile -t suites < <(find test -maxdepth 1 -type d -name 'test_*' -printf '%f\n' | sort)
-          ./bin/check-test-attribution.py --label "coverage (all areas)" \
-            --expect "${suites[*]}" testreport.xml
-
-      - name: Capture coverage information
-        if: always() # run this step even if previous step failed
-        run: |
-          sudo apt-get install -y lcov
-          lcov ${{ env.LCOV_CAPTURE_FLAGS }} --test-name tests --output-file coverage_tests.info
-          sed -i -e "s#${PWD}#.#" coverage_tests.info # Make paths relative.
-
-      - name: Attribution canary
-        # Guards the guard above: runs two suites the broken way (--without-building, so PlatformIO
-        # does not relink and both execute the same leftover binary) and requires the checker to
-        # catch it. Fails if the checker regressed, or if the reproduction stops reproducing - in
-        # which case the reason both harnesses stopped passing that flag no longer holds.
-        #
-        # Lives in this job, not simulator-tests: it relinks $BUILD_DIR/$PROGNAME, and there that
-        # replaced the daemon binary with a test suite, so the integration test waited for a socket
-        # a test binary never opens. Here the binary is already per-suite and nothing later needs it.
-        timeout-minutes: 15
-        run: ./bin/test-attribution-canary.sh -e coverage
-
-      - name: Event channel policy tests
-        run: platformio test -e coverage-event-policy -v --junit-output-path event-policy-testreport.xml
-
-      - name: Verify the event-policy suites ran their own tests
-        # Expected set read through PlatformIO's own config parser, so it cannot drift from the
-        # env's test_filter the way a second hand-maintained list would.
-        run: |
-          set -euo pipefail
-          expect=$(python3 -c "from platformio.project.config import ProjectConfig; \
-            print(' '.join(ProjectConfig().get('env:coverage-event-policy', 'test_filter', [])))")
-          ./bin/check-test-attribution.py --label coverage-event-policy \
-            --expect "$expect" event-policy-testreport.xml
+      - name: PlatformIO Tests
+        run: platformio test -e coverage -v --junit-output-path testreport.xml
 
       - name: Save test results
         if: always() # run this step even if previous step failed
@@ -467,7 +94,14 @@ jobs:
         with:
           name: platformio-test-report-${{ steps.version.outputs.long }}
           overwrite: true
-          path: ./*testreport.xml
+          path: ./testreport.xml
+
+      - name: Capture coverage information
+        if: always() # run this step even if previous step failed
+        run: |
+          sudo apt-get install -y lcov
+          lcov ${{ env.LCOV_CAPTURE_FLAGS }} --test-name tests --output-file coverage_tests.info
+          sed -i -e "s#${PWD}#.#" coverage_tests.info # Make paths relative.
 
       - name: Save coverage information
         uses: actions/upload-artifact@v7
@@ -487,10 +121,9 @@ jobs:
     needs:
       - simulator-tests
       - platformio-tests
-    # Run this job even if the previous jobs failed, but skip if the workflow was cancelled.
-    if: ${{ !cancelled() }}
+    if: always()
     steps:
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7
+      - uses: actions/checkout@v6
 
       - name: Get release version string
         run: echo "long=$(./bin/buildinfo.py long)" >> $GITHUB_OUTPUT
@@ -502,14 +135,6 @@ jobs:
           name: platformio-test-report-${{ steps.version.outputs.long }}
           merge-multiple: true
 
-      - name: Drop no-status testsuites from the report
-        # PlatformIO emits a self-closing <testsuite tests="0"/> row for every test_* dir
-        # crossed with every hardware variant it cannot run on the native host (~4900 rows).
-        # They carry no pass/fail/skip status and bury the suites that actually ran. Strip
-        # them so the Test Report lists only suites with a real status. Only the copy the
-        # reporter renders is trimmed; the uploaded artifact keeps the full XML.
-        run: sed -i -E 's#<testsuite [^>]*tests="0"[^>]*/>##g' testreport.xml
-
       - name: Test Report
         uses: dorny/test-reporter@v3.0.0
         with:
@@ -525,17 +150,9 @@ jobs:
           merge-multiple: true
 
       - name: Generate Code Coverage Report
-        # Merge every tracefile the jobs produced: coverage_base.info (zeroed baseline),
-        # coverage_integration.info, and one coverage_tests_<chunk>.info per chunk. lcov
-        # sums hit counts across them, so the merged report is the union of all chunks -
-        # identical to running the whole suite in one job.
         run: |
           sudo apt-get install -y lcov
-          args=()
-          for f in code-coverage-report/coverage_*.info; do
-            args+=(--add-tracefile "$f")
-          done
-          lcov --quiet "${args[@]}" --output-file code-coverage-report/coverage_src.info
+          lcov --quiet --add-tracefile code-coverage-report/coverage_base.info --add-tracefile code-coverage-report/coverage_integration.info --add-tracefile code-coverage-report/coverage_tests.info --output-file code-coverage-report/coverage_src.info
           genhtml --quiet --legend --prefix "${PWD}" code-coverage-report/coverage_src.info --output-directory code-coverage-report
 
       - name: Save Code Coverage Report

.github/workflows/tests.yml

@@ -20,7 +20,7 @@ jobs:
     runs-on: test-runner
     steps:
       - name: Checkout code
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
 
       # - uses: actions/setup-python@v6
       #   with:
@@ -47,7 +47,7 @@ jobs:
           pio upgrade
 
       - name: Setup Node
-        uses: actions/setup-node@v7
+        uses: actions/setup-node@v6
         with:
           node-version: 24
 

.github/workflows/trunk_annotate_pr.yml

@@ -0,0 +1,26 @@
+name: Annotate PR with trunk issues
+# See: https://github.com/trunk-io/trunk-action/blob/v1/readme.md#getting-inline-annotations-for-fork-prs
+
+on:
+  workflow_run:
+    workflows: [Pull Request] # Name from `trunk_check.yml`
+    types: [completed]
+
+permissions: read-all
+
+jobs:
+  trunk_check:
+    name: Trunk Code Quality Annotate
+    runs-on: ubuntu-24.04
+    permissions:
+      checks: write # For trunk to post annotations
+      contents: read # For repo checkout
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v6
+
+      - name: Trunk Check
+        uses: trunk-io/trunk-action@v1
+        with:
+          post-annotations: true

.github/workflows/trunk_check.yml

@@ -11,13 +11,14 @@ jobs:
     name: Trunk Check Runner
     runs-on: ubuntu-24.04
     permissions:
+      checks: write # For trunk to post annotations
       contents: read # For repo checkout
 
     steps:
       - name: Checkout
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
 
       - name: Trunk Check
-        uses: trunk-io/trunk-action@v2.0.0
+        uses: trunk-io/trunk-action@v1
         with:
-          cache: false
+          save-annotations: true

.github/workflows/update_protobufs.yml

@@ -1,74 +1,30 @@
 name: Update protobufs and regenerate classes
-on:
-  workflow_dispatch:
-    inputs:
-      protobufs_branch:
-        description: Branch of meshtastic/protobufs to generate from
-        required: true
-        type: choice
-        default: same-as-this-branch
-        options:
-          - same-as-this-branch
-          - master
-          - develop
+on: workflow_dispatch
 
 permissions: read-all
 
 jobs:
   update-protobufs:
     runs-on: ubuntu-latest
-    permissions:
+    permissions: # Needed for peter-evans/create-pull-request.
       contents: write
       pull-requests: write
     steps:
       - name: Checkout code
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           submodules: true
-          persist-credentials: false
-
-      - name: Resolve protobufs branch
-        id: resolve
-        env:
-          INPUT_BRANCH: ${{ inputs.protobufs_branch }}
-          TRIGGER_BRANCH: ${{ github.ref_name }}
-        run: |
-          set -euo pipefail
-          if [ "$INPUT_BRANCH" = "same-as-this-branch" ]; then
-            BRANCH="$TRIGGER_BRANCH"
-          else
-            BRANCH="$INPUT_BRANCH"
-          fi
-          case "$BRANCH" in
-            master | develop) ;;
-            *)
-              echo "::error::Refusing to generate from branch '$BRANCH'"
-              exit 1
-              ;;
-          esac
-          echo "branch=$BRANCH" >>"$GITHUB_OUTPUT"
 
       - name: Update submodule
-        working-directory: protobufs
-        env:
-          GIT_BRANCH: ${{ steps.resolve.outputs.branch }}
+        if: ${{ github.ref == 'refs/heads/master' || github.ref == 'refs/heads/develop' }}
         run: |
-          set -euo pipefail
-          git fetch --prune origin "+refs/heads/${GIT_BRANCH}:refs/remotes/origin/${GIT_BRANCH}"
-          git checkout --detach "refs/remotes/origin/${GIT_BRANCH}"
-          git rev-parse HEAD
+          git submodule update --remote protobufs
 
       - name: Download nanopb
-        env:
-          NANOPB_VERSION: 0.4.9.1
-          NANOPB_SHA256: 951a9ab2385424a4cdf245d0c84f4c88c6ccbc65a0dade4b246d50c068f24128
         run: |
-          set -euo pipefail
-          TARBALL="nanopb-${NANOPB_VERSION}-linux-x86.tar.gz"
-          wget -q "https://github.com/nanopb/nanopb/releases/download/nanopb-${NANOPB_VERSION}/${TARBALL}"
-          echo "${NANOPB_SHA256}  ${TARBALL}" | sha256sum -c -
-          tar xzf "${TARBALL}"
-          mv "nanopb-${NANOPB_VERSION}-linux-x86" nanopb-0.4.9
+          wget https://jpa.kapsi.fi/nanopb/download/nanopb-0.4.9.1-linux-x86.tar.gz
+          tar xvzf nanopb-0.4.9.1-linux-x86.tar.gz
+          mv nanopb-0.4.9.1-linux-x86 nanopb-0.4.9
 
       - name: Re-generate protocol buffers
         run: |
@@ -77,12 +33,10 @@ jobs:
       - name: Create pull request
         uses: peter-evans/create-pull-request@v8
         with:
-          token: ${{ secrets.GITHUB_TOKEN }}
-          branch: create-pull-request/update-protobufs-${{ github.ref_name }}-from-${{ steps.resolve.outputs.branch }}
+          branch: create-pull-request/update-protobufs
           labels: submodules
           title: Update protobufs and classes
           commit-message: Update protobufs
           add-paths: |
             protobufs
             src/mesh
-

.gitignore

@@ -1,6 +1,5 @@
 .pio
 pio
-.pio-docker
 pio.tar
 web
 web.tar
@@ -48,10 +47,6 @@ data/boot/logo.*
 managed_components/*
 arduino-lib-builder*
 dependencies.lock
-
-# JLink / RTT debug artifacts (nRF SoCs)
-flash.jlink
-rtt_*.txt
 idf_component.yml
 CMakeLists.txt
 /sdkconfig.*
@@ -61,17 +56,3 @@ CMakeLists.txt
 .python3
 .claude/scheduled_tasks.lock
 userPrefs.jsonc.mcp-session-bak
-
-# Fake-NodeDB fixture pipeline (bin/regen-fake-nodedbs.sh)
-# JSONL seeds are committed (test/fixtures/nodedb/seed_v25_*.jsonl);
-# compiled .proto outputs are ephemeral build artifacts.
-build/fixtures/
-bin/_generated/
-
-# portduino WASM build (pio run -e native-wasm) + Emscripten SDK. The artifacts land in
-# .pio/build/native-wasm/ (already ignored via .pio/); these cover the retired
-# standalone emcc build's output dirs and any in-repo emsdk checkout.
-build/wasm/
-build/wasm-obj/
-build/wasm-*.log
-.emsdk/

.gitpod.yml

@@ -0,0 +1,2 @@
+tasks:
+  - init: pip install platformio && pip install --upgrade pip

.mcp.json

@@ -1,12 +1,8 @@
 {
   "mcpServers": {
     "meshtastic": {
-      "command": "uvx",
-      "args": [
-        "--from",
-        "git+https://github.com/meshtastic/meshtastic-mcp",
-        "meshtastic-mcp"
-      ],
+      "command": "./mcp-server/.venv/bin/python",
+      "args": ["-m", "meshtastic_mcp"],
       "env": {
         "MESHTASTIC_FIRMWARE_ROOT": "."
       }

.semgrepignore

@@ -1,8 +1,2 @@
 .github/workflows/main_matrix.yml
-.github/workflows/build_windows_bin.yml
-.github/workflows/package_winget.yml
 src/mesh/compression/unishox2.cpp
-# Emscripten/WebUSB browser glue for the wasm node — not part of the firmware
-# binary or its security surface. The format-string rule false-positives on its
-# benign retry/diagnostic console logs.
-src/platform/portduino/wasm/js/

.trunk/configs/.bandit

@@ -12,10 +12,10 @@
 #   defensive loops over flaky sources (pubsub handlers, device
 #   re-enumeration polls). One failed iteration shouldn't abort the loop.
 # B404 import_subprocess
-#   the bin/ proto + fixture tooling (regen-py-protos, gen-fake-nodedb-seed,
-#   seed-json-to-proto) shells out to protoc and helper scripts — subprocess
-#   is a load-bearing import here, not a smell. The "consider possible security
-#   implications" advisory is redundant given the file-level review already applied.
+#   mcp-server wraps PlatformIO, esptool, nrfutil, picotool, and the
+#   pytest test-runner — subprocess is a load-bearing import here, not
+#   a smell. The "consider possible security implications" advisory is
+#   redundant given the file-level review already applied.
 # B603 subprocess_without_shell_equals_true
 #   all subprocess calls use a static argv list; `shell=False` is the
 #   default and we never string-interpolate user input into the command.

.trunk/trunk.yaml

@@ -4,112 +4,23 @@ cli:
 plugins:
   sources:
     - id: trunk
-      ref: v1.10.2
+      ref: v1.10.0
       uri: https://github.com/trunk-io/plugins
 lint:
-  # Custom file set + formatter that rewrites Unicode em-dash (U+2014, UTF-8
-  # bytes e2 80 94) and en-dash (U+2013, UTF-8 bytes e2 80 93) to an ASCII
-  # hyphen. The sed pattern matches the byte sequences under LC_ALL=C rather
-  # than literal characters on purpose, so the rule survives editors/hooks
-  # that themselves strip Unicode dashes. These dashes only ever appear in
-  # comments and log/error strings (LLM-authored prose), never in code, so
-  # the rewrite is purely cosmetic. Runs under `trunk fmt`; enforced by
-  # `trunk check` and the trunk-fmt-pre-commit action.
-  files:
-    - name: ascii-dash-targets
-      extensions:
-        - c
-        - cc
-        - cpp
-        - h
-        - hpp
-        - ino
-        - md
-        - py
-        - sh
-        - yaml
-        - yml
-        - json
-        - toml
-        - ini
-    - name: cpp-sources
-      extensions:
-        - c
-        - cc
-        - cpp
-        - cxx
-        - h
-        - hh
-        - hpp
-        - hxx
-        - ino
-  definitions:
-    - name: ascii-dash
-      files: [ascii-dash-targets]
-      commands:
-        - name: format
-          output: rewrite
-          formatter: true
-          run: env LC_ALL=C sed -e 's/\xe2\x80\x94/-/g' -e 's/\xe2\x80\x93/-/g' ${target}
-          success_codes: [0]
-    # Flags preprocessor conditionals that contain too many defined() terms
-    # (e.g. the 13-driver display chains in main.cpp). The compiler has no
-    # warning for this; the fix is an umbrella feature macro (HAS_TFT /
-    # HAS_SCREEN, already in src/configuration.h). Tune the limit via
-    # MAX_DEFINED in bin/lint-ifdef-complexity.sh (default 5 -> warns at 6+).
-    - name: too-many-defined
-      files: [cpp-sources]
-      commands:
-        - name: lint
-          output: regex
-          parse_regex: (?P<path>.+):(?P<line>\d+):(?P<col>\d+):(?P<severity>\w+):(?P<message>.+):(?P<code>[a-z-]+)
-          run: ${workspace}/bin/lint-ifdef-complexity.sh ${target}
-          success_codes: [0]
-          read_output_from: stdout
-    # Flags node/packet IDs logged as bare %08x instead of the 0x%08x convention in
-    # src/mesh/RadioInterface.cpp. Emits "note", trunk's only non-blocking level, so it
-    # advises without gating - including on the known pre-existing sites, which are left
-    # unlisted so they get cleaned up by whoever next edits those files.
-    - name: node-id-format
-      files: [cpp-sources]
-      commands:
-        - name: lint
-          output: regex
-          parse_regex: (?P<path>.+):(?P<line>\d+):(?P<col>\d+):(?P<severity>\w+):(?P<message>.+):(?P<code>[a-z-]+)
-          run: ${workspace}/bin/lint-node-id-format.sh ${target}
-          success_codes: [0]
-          read_output_from: stdout
-    # Flags a UNITY_END() not wrapped in exit(). A bare one ends the reporting, not the suite:
-    # the runtime keeps calling loop(), so the process never exits, its sandbox is deleted
-    # underneath it, and its .gcda and LeakSanitizer report never flush. Emits "note" because the
-    # enforcing half is bin/pio-test-isolate.sh, which catches an actual survivor at run time.
-    - name: unity-exit
-      files: [cpp-sources]
-      commands:
-        - name: lint
-          output: regex
-          parse_regex: (?P<path>.+):(?P<line>\d+):(?P<col>\d+):(?P<severity>\w+):(?P<message>.+):(?P<code>[a-z-]+)
-          run: ${workspace}/bin/lint-unity-exit.sh ${target}
-          success_codes: [0]
-          read_output_from: stdout
   enabled:
-    - ascii-dash@SYSTEM
-    - too-many-defined@SYSTEM
-    - node-id-format@SYSTEM
-    - unity-exit@SYSTEM
-    - checkov@3.3.8
-    - renovate@44.2.3
-    - prettier@3.9.6
-    - trufflehog@3.96.0
+    - checkov@3.2.529
+    - renovate@43.150.0
+    - prettier@3.8.3
+    - trufflehog@3.95.3
     - yamllint@1.38.0
     - bandit@1.9.4
-    - trivy@0.72.0
+    - trivy@0.70.0
     - taplo@0.10.0
-    - ruff@0.16.0
+    - ruff@0.15.13
     - isort@8.0.1
-    - markdownlint@0.49.1
+    - markdownlint@0.48.0
     - oxipng@10.1.1
-    - svgo@4.0.2
+    - svgo@4.0.1
     - actionlint@1.7.12
     - flake8@7.3.0
     - hadolint@2.14.0
@@ -123,44 +34,6 @@ lint:
     - linters: [ALL]
       paths:
         - bin/**
-    # Fake-NodeDB fixture JSONL files contain deterministic synthetic
-    # public_key_hex (64-char hex) values that gitleaks misidentifies as
-    # generic-api-key. These are not secrets - they're test fixtures
-    # produced by bin/gen-fake-nodedb-seed.py with a fixed RNG seed.
-    - linters: [gitleaks]
-      paths:
-        - test/fixtures/nodedb/seed_v25_*.jsonl
-    # Deliberately broken YAML: these are the inputs to bin/test-config-check.sh,
-    # which asserts that `meshtasticd --check` reports each planted fault. Prettier
-    # rejects the duplicate keys and bad indentation that are the whole point of
-    # them, so the directory is exempt. The README there is normal prose and stays
-    # linted.
-    - linters: [ALL]
-      paths:
-        - test/fixtures/portduino-config/**/*.yaml
-    # checkov/CKV_SECRET_6 flags the commented-out "large4cats" example,
-    # which is the public default credential for the meshtastic.org MQTT
-    # broker rather than a real secret. Ignore the whole file so the
-    # example config stays free of lint-suppression comments.
-    - linters: [ALL]
-      paths:
-        - userPrefs.jsonc
-    # The UA font's em/en dashes live only in trailing comments documenting
-    # each glyph's codepoint (e.g. "8212=:2549"); rewriting them would make
-    # those docs inaccurate. Glyph byte data is unaffected either way.
-    - linters: [ascii-dash]
-      paths:
-        - src/graphics/fonts/**
-    # millis()-wraparound tests pin dense clusters of hex boundary constants
-    # (0xFFFFFF00u and neighbors). trufflehog's Lob detector stitches nearby
-    # hex literals into one candidate string and the result happens to match
-    # a Lob API key shape. Not secrets - deterministic test fixtures for the
-    # 32-bit rollover.
-    - linters: [trufflehog]
-      paths:
-        - test/test_airtime/test_main.cpp
-        - test/test_throttle/test_main.cpp
-        - test/test_uptime_clock/test_main.cpp
 runtimes:
   enabled:
     - python@3.14.4

AGENTS.md

@@ -1,99 +1,73 @@
 # Agent instructions
 
-> **TL;DR**
->
-> |                |                                                                                                                        |
-> | -------------- | ---------------------------------------------------------------------------------------------------------------------- |
-> | Local tests    | `./bin/run-tests.sh` (exit 0 GREEN · 1 RED · 2 AMBER · 3 FILTERED)                                                     |
-> | Hardware tests | [meshtastic/meshtastic-mcp](https://github.com/meshtastic/meshtastic-mcp) (`MESHTASTIC_FIRMWARE_ROOT` → this checkout) |
-> | Format         | `trunk fmt`                                                                                                            |
-> | Mirror docs    | `.github/copilot-instructions.md` (canonical) · `CLAUDE.md` (Claude Code)                                              |
->
-> **Need this? It's here.**
->
-> |                                             |                                                            |
-> | ------------------------------------------- | ---------------------------------------------------------- |
-> | General helpers (clamp, UTF-8, string fmt…) | `src/meshUtils.h`                                          |
-> | Logging macros (LOG_DEBUG / INFO / WARN…)   | `src/DebugConfiguration.h`                                 |
-> | New module skeleton                         | inherit `ProtobufModule<T>` in `src/mesh/ProtobufModule.h` |
-> | Observer / event wiring                     | `src/Observer.h`                                           |
-
-This repository is the [Meshtastic](https://meshtastic.org) firmware - a C++17 embedded codebase targeting ESP32 / nRF52 / RP2040 / STM32WL / Linux-Portduino LoRa mesh radios. The Python MCP server that AI agents use to flash, configure, and test connected devices now lives in its own repo, [meshtastic/meshtastic-mcp](https://github.com/meshtastic/meshtastic-mcp); this repo registers it via `.mcp.json` (run through `uvx`) so its tools are available automatically.
+This repository is the [Meshtastic](https://meshtastic.org) firmware — a C++17 embedded codebase targeting ESP32 / nRF52 / RP2040 / STM32WL / Linux-Portduino LoRa mesh radios — plus a Python MCP server in `mcp-server/` that AI agents use to flash, configure, and test connected devices.
 
 ## Primary instruction file
 
-**Read `.github/copilot-instructions.md` first.** That file is the canonical agent-facing document for this repo. It covers project layout, coding conventions (naming, module framework, Observer pattern, thread safety), the build system, CI/CD, the native C++ test suite, and - most importantly for automation work - the **MCP Server & Hardware Test Harness** section. Read it top-to-bottom before starting any non-trivial change.
+**Read `.github/copilot-instructions.md` first.** That file is the canonical agent-facing document for this repo. It covers project layout, coding conventions (naming, module framework, Observer pattern, thread safety), the build system, CI/CD, the native C++ test suite, and — most importantly for automation work — the **MCP Server & Hardware Test Harness** section. Read it top-to-bottom before starting any non-trivial change.
 
 This file (`AGENTS.md`) is a short pointer + quick reference for agents that don't read `.github/copilot-instructions.md` by default.
 
 ## Quick command reference
 
-| Action                           | Command                                                                                                                                                               |
-| -------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| Build a firmware variant         | `pio run -e <env>` (e.g. `pio run -e rak4631`, `pio run -e heltec-v3`)                                                                                                |
-| Build native macOS host binary   | `pio run -e native-macos` (Homebrew prereqs + CH341 LoRa setup in `variants/native/portduino/platformio.ini`)                                                         |
-| Clean + rebuild                  | `pio run -e <env> -t clean && pio run -e <env>`                                                                                                                       |
-| Flash a device                   | `pio run -e <env> -t upload --upload-port <port>` (or use the `pio_flash` MCP tool)                                                                                   |
-| Run firmware unit tests (native) | `./bin/run-tests.sh` (preferred - ASan/LSan + RED/AMBER/GREEN verdict); or raw: `~/.platformio/penv/bin/python -m platformio test -e native > /tmp/test_out.txt 2>&1` |
-| Run MCP hardware tests           | From a [meshtastic-mcp](https://github.com/meshtastic/meshtastic-mcp) checkout: `MESHTASTIC_FIRMWARE_ROOT=/path/to/firmware ./run-tests.sh`                           |
-| Live TUI test runner             | `uvx --from git+https://github.com/meshtastic/meshtastic-mcp meshtastic-mcp-test-tui`                                                                                 |
-| Format before commit             | `trunk fmt`                                                                                                                                                           |
-| Regenerate protobuf bindings     | `bin/regen-protos.sh`                                                                                                                                                 |
-| Generate CI matrix               | `./bin/generate_ci_matrix.py all [--level pr]`                                                                                                                        |
+| Action                           | Command                                                                                                       |
+| -------------------------------- | ------------------------------------------------------------------------------------------------------------- |
+| Build a firmware variant         | `pio run -e <env>` (e.g. `pio run -e rak4631`, `pio run -e heltec-v3`)                                        |
+| Build native macOS host binary   | `pio run -e native-macos` (Homebrew prereqs + CH341 LoRa setup in `variants/native/portduino/platformio.ini`) |
+| Clean + rebuild                  | `pio run -e <env> -t clean && pio run -e <env>`                                                               |
+| Flash a device                   | `pio run -e <env> -t upload --upload-port <port>` (or use the `pio_flash` MCP tool)                           |
+| Run firmware unit tests (native) | `pio test -e native`                                                                                          |
+| Run MCP hardware tests           | `./mcp-server/run-tests.sh`                                                                                   |
+| Live TUI test runner             | `mcp-server/.venv/bin/meshtastic-mcp-test-tui`                                                                |
+| Format before commit             | `trunk fmt`                                                                                                   |
+| Regenerate protobuf bindings     | `bin/regen-protos.sh`                                                                                         |
+| Generate CI matrix               | `./bin/generate_ci_matrix.py all [--level pr]`                                                                |
 
 ## MCP server (device + test automation)
 
-The [meshtastic-mcp](https://github.com/meshtastic/meshtastic-mcp) server exposes ~32 MCP tools for device discovery, building, flashing, serial monitoring, and live-node administration. Tools are grouped as:
+The `mcp-server/` package exposes ~32 MCP tools for device discovery, building, flashing, serial monitoring, and live-node administration. Tools are grouped as:
 
 - **Discovery**: `list_devices`, `list_boards`, `get_board`
 - **Build & flash**: `build`, `clean`, `pio_flash`, `erase_and_flash` (ESP32 factory), `update_flash` (ESP32 OTA), `touch_1200bps`
 - **Serial sessions**: `serial_open`, `serial_read`, `serial_list`, `serial_close`
 - **Device reads**: `device_info`, `list_nodes`
 - **Device writes** (require `confirm=True`): `set_owner`, `get_config`, `set_config`, `get_channel_url`, `set_channel_url`, `send_text`, `reboot`, `shutdown`, `factory_reset`, `set_debug_log_api`
-- **Frame injection**: `inject_frame` - deliver a crafted frame into a board's real RX pipeline as if received off LoRa (reaches `from != 0` / decrypt / remote-admin paths the `toRadio` API can't). Needs firmware built with `-D MESHTASTIC_ENABLE_FRAME_INJECTION=1` (`MeshService::injectAsReceived`); sim nodes always. See the copilot-instructions **Frame injection** section.
 - **userPrefs admin**: `userprefs_get`, `userprefs_set`, `userprefs_reset`, `userprefs_manifest`, `userprefs_testing_profile`
 - **Vendor escape hatches**: `esptool_*`, `nrfutil_*`, `picotool_*`
 
-Setup: nothing to build - `.mcp.json` runs the server via `uvx --from git+https://github.com/meshtastic/meshtastic-mcp meshtastic-mcp`, so Claude Code picks it up automatically. To run the pytest hardware harness, clone [meshtastic-mcp](https://github.com/meshtastic/meshtastic-mcp) and set `MESHTASTIC_FIRMWARE_ROOT` to this firmware checkout.
+Setup: `cd mcp-server && python3 -m venv .venv && .venv/bin/pip install -e '.[test]'`. The repo registers the server via `.mcp.json` — Claude Code picks it up automatically.
 
-See the meshtastic-mcp repo's README for argument shapes and the **MCP Server & Hardware Test Harness** section of `.github/copilot-instructions.md` for agent usage rules (tool surface, fixture contract, firmware integration points, recovery playbooks).
+See `mcp-server/README.md` for argument shapes and the **MCP Server & Hardware Test Harness** section of `.github/copilot-instructions.md` for agent usage rules (tool surface, fixture contract, firmware integration points, recovery playbooks).
 
 ## Slash commands (AI-assisted workflows)
 
-The test-and-diagnose workflows (`/test`, `/diagnose`, `/repro`, `/leakhunt`) now ship with the [meshtastic-mcp](https://github.com/meshtastic/meshtastic-mcp) repo as skills - run them from a checkout of that repo (with `MESHTASTIC_FIRMWARE_ROOT` pointed here). The MCP tools they build on are still available in this repo via `.mcp.json`.
+Three test-and-diagnose workflows exist as slash commands:
+
+- **`/test` (Claude Code) / `/mcp-test` (Copilot)** — run the hardware test suite and interpret failures
+- **`/diagnose` / `/mcp-diagnose`** — read-only device health report
+- **`/repro` / `/mcp-repro`** — flakiness triage: re-run one test N times, diff firmware logs between passes and failures
+
+Bodies live in `.claude/commands/` and `.github/prompts/` respectively. `.claude/commands/README.md` is the index.
 
 ## Encryption at a glance
 
 Two layers, both in `src/mesh/CryptoEngine.cpp`:
 
-- **Channel (symmetric)** - **AES-CTR** with a channel-wide PSK (AES-128 or AES-256). Nonce = packet_id ‖ from_node ‖ block_counter. No AEAD; integrity is soft (channel-hash filter). The well-known default PSK lives in `src/mesh/Channels.h`; a 1-byte PSK is a short-form index into it.
-- **Per-peer PKI** - **X25519 ECDH** (Curve25519, 32-byte keys) → SHA-256 → **AES-256-CCM** with an 8-byte MAC. Fresh 32-bit `extraNonce` per packet, sent in the clear alongside the MAC. 12-byte wire overhead (`MESHTASTIC_PKC_OVERHEAD`). Used for DMs. Also used for remote admin (`src/modules/AdminModule.cpp`), where AdminMessage authorization is gated by `config.security.admin_key[0..2]`. Disabled entirely in Ham mode (`user.is_licensed=true`).
+- **Channel (symmetric)** — **AES-CTR** with a channel-wide PSK (AES-128 or AES-256). Nonce = packet_id ‖ from_node ‖ block_counter. No AEAD; integrity is soft (channel-hash filter). The well-known default PSK lives in `src/mesh/Channels.h`; a 1-byte PSK is a short-form index into it.
+- **Per-peer PKI** — **X25519 ECDH** (Curve25519, 32-byte keys) → SHA-256 → **AES-256-CCM** with an 8-byte MAC. Fresh 32-bit `extraNonce` per packet, sent in the clear alongside the MAC. 12-byte wire overhead (`MESHTASTIC_PKC_OVERHEAD`). Used for DMs. Also used for remote admin (`src/modules/AdminModule.cpp`), where AdminMessage authorization is gated by `config.security.admin_key[0..2]`. Disabled entirely in Ham mode (`user.is_licensed=true`).
 
-Key rotation to never trigger casually: only the **full** factory reset (`factory_reset_device`, `eraseBleBonds=true`) wipes `security.private_key` and regenerates the keypair - every peer holds the old public key, so DMs silently fail PKI decrypt until NodeInfo re-exchanges. The **partial** config reset (`factory_reset_config`) preserves the private key and doesn't invalidate peer relationships. Explicitly blanking `security.private_key` via admin also triggers regen. See the **Encryption & Key Management** section of `.github/copilot-instructions.md` for the full spec (nonce layout, send/receive selection logic including infrastructure-portnum exceptions, admin-key + session-passkey authorization, `is_managed` scope, key-rotation hazards).
+Key rotation to never trigger casually: only the **full** factory reset (`factory_reset_device`, `eraseBleBonds=true`) wipes `security.private_key` and regenerates the keypair — every peer holds the old public key, so DMs silently fail PKI decrypt until NodeInfo re-exchanges. The **partial** config reset (`factory_reset_config`) preserves the private key and doesn't invalidate peer relationships. Explicitly blanking `security.private_key` via admin also triggers regen. See the **Encryption & Key Management** section of `.github/copilot-instructions.md` for the full spec (nonce layout, send/receive selection logic including infrastructure-portnum exceptions, admin-key + session-passkey authorization, `is_managed` scope, key-rotation hazards).
 
 ## House rules
 
-- **No destructive device operations without operator approval.** `factory_reset`, `erase_and_flash`, `reboot`, `shutdown`, history-rewriting git ops - describe the action and stop. Operator authorizes.
+- **No destructive device operations without operator approval.** `factory_reset`, `erase_and_flash`, `reboot`, `shutdown`, history-rewriting git ops — describe the action and stop. Operator authorizes.
 - **One MCP call per serial port at a time.** The port lock is exclusive; concurrent calls deadlock. Sequence: open → read/mutate → close, then next device.
 - **`userPrefs.jsonc` is session state during tests.** The `_session_userprefs` fixture snapshots + restores it; never edit it from inside a test.
 - **Don't speculate about firmware root causes.** When evidence doesn't support a classification, say "unknown" and list what would disambiguate.
-- **Run `trunk fmt` before proposing a commit.** The `trunk_check` CI gate will reject unformatted code. Claude Code runs it automatically via the PostToolUse hook in `.claude/settings.json`; trunk's launcher needs `curl` or `wget` to bootstrap its pinned CLI - see **Formatting & the trunk toolchain** in `.github/copilot-instructions.md` for the no-curl bootstrap procedure.
-- **Never edit or commit files under `src/mesh/generated/`.** They are regenerated from the [`meshtastic/protobufs`](https://github.com/meshtastic/protobufs) repo by the `update_protobufs.yml` workflow (entry point: `bin/regen-protos.sh`). Local edits will be overwritten and create merge conflicts. If a `.proto` change is needed, open a PR against the protobufs repo first, then let the workflow re-sync this repo.
+- **Run `trunk fmt` before proposing a commit.** The `trunk_check` CI gate will reject unformatted code.
 - **`confirm=True` on destructive MCP tools is a real gate, not a formality.** Don't bypass it via auto-approve settings.
-- **Keep code comments minimal - one or two lines, max.** Comment only when the _why_ isn't obvious from the code; never restate what the next line does. No multi-paragraph block comments explaining straightforward changes. The diff and commit message carry the rationale; the code carries the behavior.
-- **Documentation does not live in this repo. Do not add it here.** This repository holds firmware code. There is no `docs/` directory - the design documents that used to sit there were published to [meshtastic/meshtastic](https://github.com/meshtastic/meshtastic) in #11488 and the directory was deleted - and it must not come back. Do not create a `.md` file to describe a feature, a configuration surface, an API, a wire format, or a design; write it in the docs repo and link that PR instead. Never leave a write-up behind in the tree: no investigation notes, no mitigation plans, no migration checklists, no "how we got here" narrative, no summaries of what a change did. That is what the PR description and the commit message are for, and they are the only place it belongs. When you do write documentation upstream, write a technical manual, not a novel - what the feature does, the settings it exposes in the user's terms, and the exact API or protocol a client speaks. No story of the debugging journey, no rationale essays, no changelog prose. Concise and factual, as short as the facts allow.
-- **Never compare against `millis()` directly. Use `Throttle`.** `src/mesh/Throttle.h` is the sanctioned way to ask about time, and CI enforces this (`millis-deadline-check` in `.github/workflows/test_native.yml` fails the PR on a new `millis() >` / `< millis()` comparison).
-  - `Throttle::isWithinTimespanMs(lastMs, intervalMs)` - true while still inside the cooldown.
-  - `Throttle::hasElapsed(lastMs, intervalMs)` - its complement, true once the interval has passed (inclusive `>=`). Prefer this to spelling `!isWithinTimespanMs(...)`.
-  - `Throttle::execute(&lastMs, intervalMs, func)` - function-pointer form that updates the timestamp on fire.
-  - `Throttle::deadlinePassed(deadlineMs)` - for a stored absolute deadline that cannot be re-expressed as "interval since an event".
-  - `Throttle::deadlinePassedAt(nowMs, deadlineMs)` - the same test against a caller-supplied `now`, for a loop that snapshots the clock once and tests many deadlines. Snapshot from `Time::getMillis()`.
-
-  Raw `millis() > deadline` or `deadline < millis()` is rollover-unsafe: the comparison inverts while the deadline sits on the far side of the 32-bit wrap, so the action fires immediately or blocks for roughly the interval it should have waited. All five helpers subtract first, so unsigned wraparound cancels out. `Throttle` reads the clock through `Time::getMillis()` (`src/UptimeClock.h`), so all ~94 of its call sites are time-injectable and a native test can drive the wrap with `Time::setTestMillis()`.
-
-  **Sentinel hazard.** If a deadline variable also encodes "inactive" (`0` for `rebootAtMsec`, `shutdownAtMsec`, `alertBannerUntil`, `fixHoldEnds`; `UINT32_MAX` for `nagCycleCutoff`), test that sentinel _before_ the elapsed comparison - every such value is arithmetically far in the past, so a correct comparison fires on it immediately. Match the test to the sentinel in use: `if (deadline && Throttle::deadlinePassed(deadline))` covers the `0` family, `nagCycleCutoff` needs `deadline != UINT32_MAX` or a separate armed flag (`isNagging`).
-
-  Then decide which way the sentinel should fall - "inactive" does not always mean "suppress". At the GPS fix-hold site `fixHoldEnds == 0` means _no hold is in force_, which is exactly when one must be armed; guarding it with `fixHoldEnds != 0 &&` looks like this rule and inverts the site. See `fixHoldInForce()` in `src/gps/GPS.cpp` and `test/test_gps_fix_hold/`.
+- **Keep code comments minimal — one or two lines, max.** Comment only when the _why_ isn't obvious from the code; never restate what the next line does. No multi-paragraph block comments explaining straightforward changes. The diff and commit message carry the rationale; the code carries the behavior.
+- **Use `Throttle` for time-based rate limiting, not raw `millis()` math.** `src/mesh/Throttle.h` provides `Throttle::isWithinTimespanMs(lastMs, intervalMs)` (returns true while inside the cooldown) and `Throttle::execute(&lastMs, intervalMs, func)` (function-pointer form that updates the timestamp on fire). Use these for any "did N ms pass since X" check — raw `millis() > lastMs + N` is rollover-unsafe (breaks after ~49.7 days) and inconsistent with the rest of the codebase. The helpers compute `now - lastMs` with unsigned subtraction, which wraps correctly.
 
 ## Typical agent workflows
 
@@ -105,9 +79,9 @@ Key rotation to never trigger casually: only the **full** factory reset (`factor
 
 ### Inspecting live node state
 
-1. `device_info(port=...)` - short summary (node num, firmware version, region, peer count)
-2. `list_nodes(port=...)` - full peer table (SNR, RSSI, pubkey presence, last_heard)
-3. `get_config(section="lora", port=...)` - LoRa settings for cross-device comparison
+1. `device_info(port=...)` — short summary (node num, firmware version, region, peer count)
+2. `list_nodes(port=...)` — full peer table (SNR, RSSI, pubkey presence, last_heard)
+3. `get_config(section="lora", port=...)` — LoRa settings for cross-device comparison
 
 Sequence these; don't parallelize on the same port.
 
@@ -115,49 +89,42 @@ Sequence these; don't parallelize on the same port.
 
 1. Build locally: `pio run -e <env>`
 2. Flash the test device: `pio_flash(env=..., port=..., confirm=True)`
-3. Run the suite from a meshtastic-mcp checkout: `MESHTASTIC_FIRMWARE_ROOT=/path/to/firmware ./run-tests.sh tests/<tier>` (or the `/test` skill)
-4. On failure, open the run's `tests/report.html` → `Meshtastic debug` section for the firmware log tail + device state dump
+3. Run the suite: `./mcp-server/run-tests.sh tests/<tier>` or `/test tests/<tier>`
+4. On failure, open `mcp-server/tests/report.html` → `Meshtastic debug` section for the firmware log tail + device state dump
 5. Iterate
 
-### Debugging a native unit-test failure
+### Debugging a flaky test
 
-1. **Run the full suite before believing a filtered one.** `-f` is not a gate: it removes the suites that _create_ the shared state a later suite trips over.
-2. **A signal name is not a crash.** `exit(UNITY_END())` returns the failure count and PlatformIO renders it as a signal (4 -> `SIGILL`, 5 -> `SIGTRAP`), reporting `[ERRORED]`. Match it against the failure count first.
-3. **Check the CLEAN/DIRTY axis.** Each suite runs in its own scratch `$HOME`; deliberate writes are declared in `test/state-manifest.tsv`. A DIRTY verdict names the suite and the undeclared path, and the kept sandbox under `.pio/test-state/<suite>/` is a replayable reproduction.
-4. **Sanitizers are per env** - `coverage` has ASan/LSan, `native` has none. Don't reason from ASan on a `-e native` run.
-5. **Reproduce a shuffled order.** `--shuffle` prints its seed and puts it on the `RESULT:` line; `--seed <n>` replays that exact order. One green seed proves nothing about order independence.
-6. **Exit 2 with "Linux-only" is the host, not the tests.** The harness needs bash 4+ and GNU coreutils/find and rejects any other `uname` rather than degrade quietly. `native-macos` is a build target, not a test host; elsewhere use `./bin/test-native-docker.sh`.
-
-### Debugging a flaky hardware test
-
-1. `/repro <test-node-id> [count]` - re-runs the test N times, diffs firmware logs between passes and failures
+1. `/repro <test-node-id> [count]` — re-runs the test N times, diffs firmware logs between passes and failures
 2. If the first attempt always fails and the rest pass, that's a state-leak pattern → suggest `--force-bake` or a clean device state, don't chase the first failure
-3. If all N fail, this isn't a flake - it's a regression. Stop iterating and escalate to `/test` for full-suite context.
+3. If all N fail, this isn't a flake — it's a regression. Stop iterating and escalate to `/test` for full-suite context.
 
 ## Where to look
 
-| Path                                                           | What's there                                                                                                                                                                                   |
-| -------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `src/`                                                         | Firmware C++ source (`mesh/`, `modules/`, `platform/`, `graphics/`, `gps/`, `motion/`, `mqtt/`, …)                                                                                             |
-| `src/mesh/`                                                    | Core: NodeDB, Router, Channels, CryptoEngine, radio interfaces, StreamAPI, PhoneAPI                                                                                                            |
-| `src/modules/`                                                 | Feature modules; `Telemetry/Sensor/` has 50+ I2C sensor drivers                                                                                                                                |
-| `variants/`                                                    | 200+ hardware variant definitions (`variant.h` + `platformio.ini` per board)                                                                                                                   |
-| `protobufs/`                                                   | `.proto` definitions; regenerate with `bin/regen-protos.sh`                                                                                                                                    |
-| `test/`                                                        | Firmware unit tests (count = the `test_*` dirs, detected on the fly; `./bin/run-tests.sh` preferred, falls back to `pio test -e native`)                                                       |
-| [meshtastic-mcp](https://github.com/meshtastic/meshtastic-mcp) | Standalone MCP server + tiered pytest hardware harness (`unit/`, `mesh/`, `telemetry/`, `monitor/`, `recovery/`, `ui/`, `fleet/`, `admin/`, `provisioning/`) - registered here via `.mcp.json` |
-| `.github/prompts/`                                             | Copilot prompt bodies (firmware scaffolding: new module / sensor / variant)                                                                                                                    |
-| `.github/copilot-instructions.md`                              | **Primary agent instructions - read this**                                                                                                                                                     |
-| `.github/workflows/`                                           | CI pipelines                                                                                                                                                                                   |
-| `.mcp.json`                                                    | MCP server registration for Claude Code                                                                                                                                                        |
+| Path                              | What's there                                                                                                             |
+| --------------------------------- | ------------------------------------------------------------------------------------------------------------------------ |
+| `src/`                            | Firmware C++ source (`mesh/`, `modules/`, `platform/`, `graphics/`, `gps/`, `motion/`, `mqtt/`, …)                       |
+| `src/mesh/`                       | Core: NodeDB, Router, Channels, CryptoEngine, radio interfaces, StreamAPI, PhoneAPI                                      |
+| `src/modules/`                    | Feature modules; `Telemetry/Sensor/` has 50+ I2C sensor drivers                                                          |
+| `variants/`                       | 200+ hardware variant definitions (`variant.h` + `platformio.ini` per board)                                             |
+| `protobufs/`                      | `.proto` definitions; regenerate with `bin/regen-protos.sh`                                                              |
+| `test/`                           | Firmware unit tests (12 suites; `pio test -e native`)                                                                    |
+| `mcp-server/`                     | Python MCP server + pytest hardware integration tests                                                                    |
+| `mcp-server/tests/`               | Tiered pytest suite: `unit/`, `mesh/`, `telemetry/`, `monitor/`, `recovery/`, `ui/`, `fleet/`, `admin/`, `provisioning/` |
+| `.claude/commands/`               | Claude Code slash command bodies                                                                                         |
+| `.github/prompts/`                | Copilot prompt bodies (mirrors of the Claude Code ones)                                                                  |
+| `.github/copilot-instructions.md` | **Primary agent instructions — read this**                                                                               |
+| `.github/workflows/`              | CI pipelines                                                                                                             |
+| `.mcp.json`                       | MCP server registration for Claude Code                                                                                  |
 
 ## Recovery one-liners
 
-- **`userPrefs.jsonc` dirty after a test run?** Re-run the meshtastic-mcp harness once (pre-flight self-heals from the sidecar). If still dirty: `git checkout userPrefs.jsonc`.
+- **`userPrefs.jsonc` dirty after a test run?** Re-run `./mcp-server/run-tests.sh` once (pre-flight self-heals from the sidecar). If still dirty: `git checkout userPrefs.jsonc`.
 - **nRF52 not responding?** `mcp__meshtastic__touch_1200bps(port=...)` drops it into the DFU bootloader, then `pio_flash` re-installs.
 - **Device fully wedged (no DFU)?** `mcp__meshtastic__uhubctl_cycle(role="nrf52", confirm=True)` hard-power-cycles it via USB hub PPPS. Needs `uhubctl` installed (`brew install uhubctl` / `apt install uhubctl`); on Linux without udev rules, permission errors fail fast, so use `sudo uhubctl` yourself or configure udev access.
 - **Port busy?** `lsof <port>` to find the holder. Usually a stale `pio device monitor` or zombie `meshtastic_mcp` process. Kill it.
-- **Multiple MCP servers running?** `ps aux | grep meshtastic_mcp` - zombies hold ports. Kill all but the one your host spawned.
-- **macOS: `LIBUSB_ERROR_BUSY` on a CH341 LoRa adapter?** A third-party WCH `CH34xVCPDriver` is claiming interface 0. Find the bundle ID with `ioreg -p IOUSB -l -w 0 | grep -B2 -A30 0x5512`, then `sudo kmutil unload -b <bundleID>`. Apple's bundled CH34x kext targets the CH340 UART (PID 0x7523), not the SPI bridge - it's never the culprit.
+- **Multiple MCP servers running?** `ps aux | grep meshtastic_mcp` — zombies hold ports. Kill all but the one your host spawned.
+- **macOS: `LIBUSB_ERROR_BUSY` on a CH341 LoRa adapter?** A third-party WCH `CH34xVCPDriver` is claiming interface 0. Find the bundle ID with `ioreg -p IOUSB -l -w 0 | grep -B2 -A30 0x5512`, then `sudo kmutil unload -b <bundleID>`. Apple's bundled CH34x kext targets the CH340 UART (PID 0x7523), not the SPI bridge — it's never the culprit.
 
 ## Environment variables (test harness)
 
@@ -168,7 +135,7 @@ Sequence these; don't parallelize on the same port.
 | `MESHTASTIC_MCP_FLASH_LOG`           | File path to tee pio/esptool/nrfutil/picotool output. `run-tests.sh` sets this to `tests/flash.log` so the TUI can stream live flash progress.                                                             |
 | `MESHTASTIC_MCP_TCP_HOST`            | `host` or `host:port` of a `meshtasticd` daemon (e.g. the `native-macos` build). Surfaces it in `list_devices` as `tcp://host:port` so `connect()`-based tools target it transparently. Default port 4403. |
 | `MESHTASTIC_UHUBCTL_BIN`             | Absolute path to `uhubctl` binary. Default: PATH lookup.                                                                                                                                                   |
-| `MESHTASTIC_UHUBCTL_LOCATION_<ROLE>` | Pin a role to a specific uhubctl hub location (e.g. `1-1.3`). Wins over VID auto-detection - use when multiple devices share a VID.                                                                        |
+| `MESHTASTIC_UHUBCTL_LOCATION_<ROLE>` | Pin a role to a specific uhubctl hub location (e.g. `1-1.3`). Wins over VID auto-detection — use when multiple devices share a VID.                                                                        |
 | `MESHTASTIC_UHUBCTL_PORT_<ROLE>`     | Pin a role to a specific hub port number. Required alongside `LOCATION_<ROLE>`.                                                                                                                            |
 | `MESHTASTIC_UI_CAMERA_BACKEND`       | Camera backend for UI tier + `capture_screen` tool: `opencv` / `ffmpeg` / `null` / `auto` (default).                                                                                                       |
 | `MESHTASTIC_UI_CAMERA_DEVICE`        | Generic camera device (index or path). Used by the UI tier when no per-role var is set.                                                                                                                    |

CLAUDE.md

@@ -1,28 +0,0 @@
-# Claude Code instructions
-
-> **TL;DR**
->
-> |                |                                                                                                                        |
-> | -------------- | ---------------------------------------------------------------------------------------------------------------------- |
-> | Local tests    | `./bin/run-tests.sh` (exit 0 GREEN · 1 RED · 2 AMBER · 3 FILTERED)                                                     |
-> | Hardware tests | [meshtastic/meshtastic-mcp](https://github.com/meshtastic/meshtastic-mcp) (`MESHTASTIC_FIRMWARE_ROOT` → this checkout) |
-> | Format         | `trunk fmt`                                                                                                            |
-> | Mirror docs    | `.github/copilot-instructions.md` (canonical) · `AGENTS.md`                                                            |
->
-> **Need this? It's here.**
->
-> |                                                           |                                                            |
-> | --------------------------------------------------------- | ---------------------------------------------------------- |
-> | General helpers (clamp, UTF-8, string fmt…)               | `src/meshUtils.h`                                          |
-> | Logging macros (LOG_DEBUG / INFO / WARN…)                 | `src/DebugConfiguration.h`                                 |
-> | Elapsed time / deadlines (never bare `millis()` compares) | `src/mesh/Throttle.h`                                      |
-> | New module skeleton                                       | inherit `ProtobufModule<T>` in `src/mesh/ProtobufModule.h` |
-> | Observer / event wiring                                   | `src/Observer.h`                                           |
-
-**Read `.github/copilot-instructions.md` first.** That file is the canonical agent-facing document for this repo. It covers project layout, coding conventions, the build system, CI/CD, the native C++ test suite, and the MCP Server & Hardware Test Harness. Read it top-to-bottom before starting any non-trivial change.
-
-This file (`CLAUDE.md`) is a short pointer for Claude Code sessions. Slash commands live in `.claude/commands/`.
-
-## House rule: documentation does not live in this repo
-
-This repository holds firmware code. There is no `docs/` directory - the design documents that used to sit there were published to [meshtastic/meshtastic](https://github.com/meshtastic/meshtastic) in #11488 and the directory was deleted - and it must not come back. Do not create a `.md` file to describe a feature, a configuration surface, an API, a wire format, or a design; write it in the docs repo and link that PR instead. Never leave a write-up behind in the tree: no investigation notes, no mitigation plans, no migration checklists, no "how we got here" narrative, no summaries of what a change did. That is what the PR description and the commit message are for, and they are the only place it belongs. When you do write documentation upstream, write a technical manual, not a novel - what the feature does, the settings it exposes in the user's terms, and the exact API or protocol a client speaks. No story of the debugging journey, no rationale essays, no changelog prose. Concise and factual, as short as the facts allow.

Dockerfile

@@ -1,5 +1,4 @@
-# trunk-ignore-all(trivy/DS-0002): We must run as root for this container
-# trunk-ignore-all(checkov/CKV_DOCKER_8): We must run as root for this container
+# trunk-ignore-all(trivy/DS002): We must run as root for this container
 # trunk-ignore-all(hadolint/DL3002): We must run as root for this container
 # trunk-ignore-all(hadolint/DL3008): Do not pin apt package versions
 # trunk-ignore-all(hadolint/DL3013): Do not pin pip package versions
@@ -15,8 +14,8 @@ ENV PIP_BREAK_SYSTEM_PACKAGES=1
 RUN apt-get update && apt-get install --no-install-recommends -y \
         curl wget g++ zip git ca-certificates pkg-config \
         python3-pip python3-grpc-tools \
-        libgpiod-dev libyaml-cpp-dev libjsoncpp-dev libbluetooth-dev libi2c-dev libuv1-dev \
-        libcurl4-gnutls-dev libusb-1.0-0-dev libulfius-dev liborcania-dev libssl-dev \
+        libgpiod-dev libyaml-cpp-dev libbluetooth-dev libi2c-dev libuv1-dev \
+        libusb-1.0-0-dev libulfius-dev liborcania-dev libssl-dev \
         libx11-dev libinput-dev libxkbcommon-x11-dev libsqlite3-dev libsdl2-dev \
     && apt-get clean && rm -rf /var/lib/apt/lists/* \
     && pip install --no-cache-dir -U platformio \
@@ -54,8 +53,8 @@ ENV TZ=Etc/UTC
 USER root
 
 RUN apt-get update && apt-get --no-install-recommends -y install \
-        libc-bin libc6 libgpiod3 libyaml-cpp0.8 libjsoncpp26 libi2c0 libuv1t64 libusb-1.0-0-dev \
-        libcurl4t64 liborcania2.3 libulfius2.7t64 libssl3t64 \
+        libc-bin libc6 libgpiod3 libyaml-cpp0.8 libi2c0 libuv1t64 libusb-1.0-0-dev \
+        liborcania2.3 libulfius2.7t64 libssl3t64 \
         libx11-6 libinput10 libxkbcommon-x11-0 libsdl2-2.0-0 \
     && apt-get clean && rm -rf /var/lib/apt/lists/* \
     && mkdir -p /var/lib/meshtasticd \

Dockerfile.test

@@ -7,7 +7,7 @@ ENV PIP_ROOT_USER_ACTION=ignore
 # hadolint ignore=DL3008
 RUN apt-get update && apt-get install --no-install-recommends -y \
         g++ git ca-certificates pkg-config \
-        libgpiod-dev libyaml-cpp-dev libjsoncpp-dev libbluetooth-dev libi2c-dev libuv1-dev \
+        libgpiod-dev libyaml-cpp-dev libbluetooth-dev libi2c-dev libuv1-dev \
         libusb-1.0-0-dev libulfius-dev liborcania-dev libssl-dev \
         libx11-dev libinput-dev libxkbcommon-x11-dev libsqlite3-dev libsdl2-dev \
     && apt-get clean && rm -rf /var/lib/apt/lists/* \

README.md

@@ -29,8 +29,8 @@ Meshtastic enables text messaging, location sharing, and telemetry over a decent
 
 ### Get Started
 
-- 🔧 **[Building Instructions](https://meshtastic.org/docs/development/firmware/build)** - Learn how to compile the firmware from source.
-- ⚡ **[Flashing Instructions](https://meshtastic.org/docs/getting-started/flashing-firmware/)** - Install or update the firmware on your device.
+- 🔧 **[Building Instructions](https://meshtastic.org/docs/development/firmware/build)** – Learn how to compile the firmware from source.
+- ⚡ **[Flashing Instructions](https://meshtastic.org/docs/getting-started/flashing-firmware/)** – Install or update the firmware on your device.
 
 Join our community and help improve Meshtastic! 🚀
 

SECURITY.md

@@ -10,35 +10,3 @@
 ## Reporting a Vulnerability
 
 We support the private reporting of potential security vulnerabilities. Please go to the Security tab to file a report with a description of the potential vulnerability and reproduction scripts (preferred) or steps, and our developers will review.
-
-Before filing, please read the Security Model below. Behavior whose only precondition is local API access to a node, or possession of a channel's pre-shared key, is intended by design and is not considered a vulnerability.
-
-## Security Model
-
-Meshtastic is an off-grid mesh protocol that runs on constrained microcontrollers within a 256 byte LoRa packet limit. These constraints shape its security design and rule out the heavier schemes used by IP-based protocols. This section summarizes what the firmware protects, the assumptions it rests on, and its known limits. Fuller write-ups are in the documentation:
-
-- Encryption overview: https://meshtastic.org/docs/overview/encryption/
-- Technical reference: https://meshtastic.org/docs/development/reference/encryption-technical/
-- Known limitations and future work: https://meshtastic.org/docs/about/overview/encryption/limitations/
-
-### Cryptographic mechanisms
-
-- Channels are encrypted with a pre-shared key (PSK) using AES256-CTR. Channel traffic is encrypted but not authenticated, so anyone holding the PSK can read channel messages and can send messages as any node on that channel.
-- Direct messages and admin messages use public key cryptography (x25519 key exchange with AES-CCM), providing confidentiality, authentication, and integrity between nodes on 2.5.0 or newer that have exchanged keys.
-- Admin sessions use short-lived session IDs to limit replay of control messages.
-
-### Local trust boundary
-
-A client connected to a node over Bluetooth, USB serial, WiFi, or Ethernet has full local API access. From that connection it can read decrypted traffic, send messages as the node, change configuration (subject to managed mode), and read the node's private key for backup. This is intended behavior. The firmware trusts the local link the same way a phone or laptop trusts a directly attached device, and anything within reach of that connection (a shared LAN, a USB cable to an untrusted host, a paired phone) should be treated as part of the node itself.
-
-### Node identity (Trust On First Use)
-
-There is no central authority to sign node keys. The first public key a node hears for a given node number is the one it binds to that node number, a Trust On First Use (TOFU) model that is a hard requirement of a decentralized mesh. Clients and firmware reduce the impact of this by keeping favorited nodes from rolling out of the node database and by flagging public-key changes in the client UI.
-
-Firmware 2.8.X adds XEdDSA packet signing to further secure node identity claims and the authenticity of subsequent messages. It reuses each node's existing x25519 key pair to produce signatures, so a receiver can verify that a packet came from the holder of the bound key. Once a node has been seen signing, unsigned packets claiming that identity can be rejected.
-
-### Known limitations
-
-- No perfect forward secrecy. Traffic captured today can be decrypted later if a key is compromised, for example through a lost node or a mishandled channel key.
-- Channel messages are not authenticated, as noted above. Although as of 2.8, channel messages will be xedDSA signed as a means of verification that is non-breaking.
-- Setting WiFi credentials, or performing any other local administration, on an ESP32 over an untrusted network exposes that traffic, including the credentials, to the network. Provision and administer nodes over a trusted channel instead: Bluetooth, USB serial, or remote admin over the mesh. There is no current roadmap item to secure local administration over untrusted WiFi, though it may be addressed in a future release.

alpine.Dockerfile

@@ -1,11 +1,10 @@
-# trunk-ignore-all(trivy/DS-0002): We must run as root for this container
-# trunk-ignore-all(checkov/CKV_DOCKER_8): We must run as root for this container
+# trunk-ignore-all(trivy/DS002): We must run as root for this container
 # trunk-ignore-all(hadolint/DL3002): We must run as root for this container
 # trunk-ignore-all(hadolint/DL3018): Do not pin apk package versions
 # trunk-ignore-all(hadolint/DL3013): Do not pin pip package versions
 
 # Ensure the Alpine version is updated in both stages of the container!
-FROM alpine:3.24 AS builder
+FROM alpine:3.23 AS builder
 ARG PIO_ENV=native
 
 # Enable Alpine community repository (for 'py3-grpcio-tools')
@@ -17,7 +16,7 @@ ENV PIP_BREAK_SYSTEM_PACKAGES=1
 RUN apk --no-cache add \
         bash g++ libstdc++-dev linux-headers zip git ca-certificates libbsd-dev \
         py3-pip py3-grpcio-tools \
-        libgpiod-dev yaml-cpp-dev jsoncpp-dev bluez-dev curl-dev \
+        libgpiod-dev yaml-cpp-dev bluez-dev \
         libusb-dev i2c-tools-dev libuv-dev openssl-dev pkgconf argp-standalone \
         libx11-dev libinput-dev libxkbcommon-dev sqlite-dev sdl2-dev \
     && rm -rf /var/cache/apk/* \
@@ -36,7 +35,7 @@ RUN bash ./bin/build-native.sh "$PIO_ENV" && \
 
 # ##### PRODUCTION BUILD #############
 
-FROM alpine:3.24
+FROM alpine:3.23
 LABEL org.opencontainers.image.title="Meshtastic" \
       org.opencontainers.image.description="Alpine Meshtastic daemon" \
       org.opencontainers.image.url="https://meshtastic.org" \
@@ -49,8 +48,8 @@ LABEL org.opencontainers.image.title="Meshtastic" \
 USER root
 
 RUN apk --no-cache add \
-        shadow libstdc++ libbsd libgpiod yaml-cpp jsoncpp libusb \
-        libcurl i2c-tools libuv libx11 libinput libxkbcommon sdl2 \
+        shadow libstdc++ libbsd libgpiod yaml-cpp libusb \
+        i2c-tools libuv libx11 libinput libxkbcommon sdl2 \
     && rm -rf /var/cache/apk/* \
     && mkdir -p /var/lib/meshtasticd \
     && mkdir -p /etc/meshtasticd/config.d \

bin/_rewrite_proto_namespace.py

@@ -1,64 +0,0 @@
-#!/usr/bin/env python3
-"""Post-process protoc-generated Python files to live under a local namespace.
-
-Called by bin/regen-py-protos.sh. Walks the generated *_pb2.py files in the
-target directory and rewrites every `meshtastic` reference (imports, dotted
-attribute access) to use the new namespace (e.g., `meshtastic_v25`).
-
-Why: the .proto files declare `package meshtastic;`, so protoc emits
-`from meshtastic import mesh_pb2 as ...` lines. That would shadow the PyPI
-`meshtastic` package which the meshtastic-mcp tooling depends on. Renaming
-to a local namespace keeps both available.
-
-Usage:
-    _rewrite_proto_namespace.py <generated_dir> <new_namespace>
-"""
-
-from __future__ import annotations
-
-import pathlib
-import re
-import sys
-
-
-def rewrite(dir_path: pathlib.Path, new_ns: str) -> int:
-    # Standard protoc import forms:
-    #   from meshtastic.X_pb2 import ...     (rare, for direct symbol pulls)
-    #   from meshtastic import X_pb2 as ...  (common, the cross-file ref)
-    #   import meshtastic.X_pb2              (also possible)
-    pattern_dotted_from = re.compile(r"^from meshtastic\.", re.MULTILINE)
-    pattern_bare_from = re.compile(r"^from meshtastic import ", re.MULTILINE)
-    pattern_dotted_import = re.compile(r"^import meshtastic\.", re.MULTILINE)
-
-    count = 0
-    for p in dir_path.glob("*.py"):
-        text = p.read_text(encoding="utf-8")
-        new = pattern_dotted_from.sub(f"from {new_ns}.", text)
-        new = pattern_bare_from.sub(f"from {new_ns} import ", new)
-        new = pattern_dotted_import.sub(f"import {new_ns}.", new)
-        # NOTE: we deliberately leave `meshtastic/X.proto` source-filename
-        # references inside descriptor strings alone. The descriptor pool is
-        # keyed by source filename (independent of Python package layout), so
-        # those don't collide with the PyPI package's descriptors.
-        if new != text:
-            p.write_text(new, encoding="utf-8")
-            count += 1
-    return count
-
-
-def main(argv: list[str]) -> int:
-    if len(argv) != 2:
-        print("usage: _rewrite_proto_namespace.py <generated_dir> <new_namespace>", file=sys.stderr)
-        return 2
-    dir_path = pathlib.Path(argv[0])
-    new_ns = argv[1]
-    if not dir_path.is_dir():
-        print(f"directory not found: {dir_path}", file=sys.stderr)
-        return 2
-    n = rewrite(dir_path, new_ns)
-    print(f"rewrote {n} file(s) in {dir_path} → namespace {new_ns}", file=sys.stderr)
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main(sys.argv[1:]))

bin/bme680_iaq_replay.cpp

@@ -1,100 +0,0 @@
-// Replays a captured BME680 CSV trace (gas_ohms,rh[,bsec_iaq]) through
-// BME680IaqEstimator for offline tuning. See docs/bme680_iaq_replay.md.
-
-#include "modules/Telemetry/Sensor/BME680IaqEstimator.h"
-
-#include <cmath>
-#include <cstdio>
-
-namespace
-{
-// Same buckets the device UI uses (EnvironmentTelemetry drawFrame)
-int band(int iaq)
-{
-    if (iaq <= 25)
-        return 0; // Excellent
-    if (iaq <= 50)
-        return 1; // Good
-    if (iaq <= 100)
-        return 2; // Moderate
-    if (iaq <= 150)
-        return 3; // Poor
-    if (iaq <= 200)
-        return 4; // Unhealthy
-    if (iaq <= 300)
-        return 5; // Very Unhealthy
-    return 6;     // Hazardous
-}
-} // namespace
-
-int main(int argc, char **argv)
-{
-    FILE *in = stdin;
-    if (argc > 1) {
-        in = fopen(argv[1], "r");
-        if (!in) {
-            fprintf(stderr, "cannot open %s\n", argv[1]);
-            return 1;
-        }
-    }
-
-    BME680IaqEstimator est;
-    char line[256];
-    long lineNo = 0, n = 0, skipped = 0, produced = 0, compared = 0, bandHits = 0;
-    double absErrSum = 0;
-
-    printf("n,gas_ohms,rh,est_iaq,bsec_iaq\n");
-    while (fgets(line, sizeof(line), in)) {
-        lineNo++;
-        if (line[0] == '#' || line[0] == '\n')
-            continue;
-        float gas, rh, bsec = NAN;
-        int fields = sscanf(line, "%f,%f,%f", &gas, &rh, &bsec);
-        if (fields < 2) {
-            // Tolerate one header row silently; anything else malformed is
-            // reported so a damaged trace can't produce a quiet, biased summary
-            if (lineNo > 1) {
-                skipped++;
-                fprintf(stderr, "skipping malformed line %ld: %s", lineNo, line);
-            }
-            continue;
-        }
-        n++;
-        uint16_t iaq;
-        bool got = est.update(gas, rh, &iaq);
-        bool haveBsec = fields >= 3 && std::isfinite(bsec);
-
-        printf("%ld,%.0f,%.2f,", n, gas, rh);
-        if (got)
-            printf("%u", (unsigned)iaq);
-        if (haveBsec)
-            printf(",%.0f\n", bsec);
-        else
-            printf(",\n");
-
-        if (got) {
-            produced++;
-            if (haveBsec) {
-                compared++;
-                absErrSum += std::fabs((double)iaq - (double)bsec);
-                if (band(iaq) == band((int)std::lround(bsec)))
-                    bandHits++;
-            }
-        }
-    }
-    if (ferror(in)) {
-        fprintf(stderr, "input read error at line %ld\n", lineNo);
-        if (in != stdin)
-            fclose(in);
-        return 1;
-    }
-
-    fprintf(stderr, "samples: %ld, estimator outputs: %ld, malformed lines skipped: %ld\n", n, produced, skipped);
-    if (compared) {
-        fprintf(stderr, "vs BSEC (%ld comparable): mean abs error %.1f IAQ points, band agreement %.1f%%\n", compared,
-                absErrSum / compared, 100.0 * bandHits / compared);
-    }
-    if (in != stdin)
-        fclose(in);
-    return 0;
-}

bin/build-esp32.sh

@@ -12,8 +12,7 @@ rm -f $OUTDIR/firmware*
 rm -r $OUTDIR/* || true
 
 # Important to pull latest version of libs into all device flavors, otherwise some devices might be stale
-# platformio pkg install -e $1
-# ...redundant with pioarduino
+platformio pkg install -e $1
 
 echo "Building for $1 with $PLATFORMIO_BUILD_FLAGS"
 rm -f $BUILDDIR/firmware*
@@ -39,4 +38,4 @@ cp bin/device-install.* $OUTDIR/
 cp bin/device-update.* $OUTDIR/
 
 echo "Copying manifest"
-cp $BUILDDIR/$basename.mt.json $OUTDIR/$basename.mt.json
+cp $BUILDDIR/$basename.mt.json $OUTDIR/$basename.mt.json || true

bin/build-winget-package.ps1

@@ -1,292 +0,0 @@
-#!/usr/bin/env pwsh
-#Requires -Version 7.0
-
-<#
-.SYNOPSIS
-    Builds the meshtasticd MSI and the winget manifests that install it.
-
-.DESCRIPTION
-    Writes the MSI and the three winget manifests into -OutputDirectory. The installer manifest
-    pins the MSI's SHA256, so the file must be published unchanged at -InstallerUrl.
-
-    WiX is required, pinned below v6, which refuses to build without accepting the OSMF EULA:
-
-        dotnet tool install --global wix --version 5.0.2
-        wix extension add -g WixToolset.Util.wixext/5.0.2
-
-.EXAMPLE
-    platformio run -e native-windows
-    ./bin/build-winget-package.ps1 -Validate
-
-.EXAMPLE
-    ./bin/build-winget-package.ps1 -Version 2.8.0 -ReleaseTag v2.8.0.1e982fa
-#>
-
-[CmdletBinding()]
-param(
-    [string]$BinaryPath,
-    [string]$SampleConfigPath,
-    # Generate manifests for an MSI that already exists (a published release asset) instead of
-    # building one. WiX is not needed in that mode.
-    [string]$MsiPath,
-    [string]$Version,
-    [string]$ReleaseTag,
-    [string]$OutputDirectory,
-    [string]$PackageIdentifier = 'Meshtastic.Meshtasticd',
-    [ValidateSet('x64', 'arm64')]
-    [string]$Architecture = 'x64',
-    [string]$InstallerUrl,
-    [string]$ManifestVersion = '1.6.0',
-    [switch]$Validate
-)
-
-Set-StrictMode -Version Latest
-$ErrorActionPreference = 'Stop'
-
-$RepoRoot = (Resolve-Path (Join-Path $PSScriptRoot '..')).Path
-$WxsPath = Join-Path $RepoRoot 'packaging/windows/meshtasticd.wxs'
-
-# Same UpgradeCode as the .wxs; also the namespace for the per-version ProductCode below.
-$UpgradeCode = '8f2c6d41-5b3a-4c8e-9f27-1d0a6b4e73c5'
-
-function Get-RepoVersion {
-    param([string]$PropertiesPath)
-
-    $text = Get-Content -LiteralPath $PropertiesPath -Raw
-    $fields = foreach ($name in 'major', 'minor', 'build') {
-        $match = [regex]::Match($text, "(?m)^\s*$name\s*=\s*(\d+)\s*$")
-        if (-not $match.Success) {
-            throw "Could not read '$name' from $PropertiesPath"
-        }
-        $match.Groups[1].Value
-    }
-    $short = $fields -join '.'
-
-    # Mirrors bin/readprops.py: the release tag carries a 7-char SHA, the package version does not.
-    # Empty on a failed or absent git, in which case the tag falls back to the bare version.
-    $sha = ''
-    try {
-        $sha = (git -C $RepoRoot rev-parse --short=7 HEAD 2>$null | Select-Object -First 1)
-    } catch {
-        $sha = ''
-    }
-
-    [pscustomobject]@{
-        Short = $short
-        Long  = if ($sha) { "$short.$($sha.Trim())" } else { $short }
-    }
-}
-
-function New-DeterministicGuid {
-    param(
-        [Parameter(Mandatory)][string]$Namespace,
-        [Parameter(Mandatory)][string]$Name
-    )
-
-    # RFC 4122 name-based (v5) UUID. Windows Installer wants a fresh ProductCode per version for
-    # major upgrades to work, and deriving it keeps that reproducible across rebuilds.
-    $bytes = ([guid]$Namespace).ToByteArray()
-    # .NET lays the first three fields out little-endian; RFC 4122 hashes them big-endian.
-    [array]::Reverse($bytes, 0, 4)
-    [array]::Reverse($bytes, 4, 2)
-    [array]::Reverse($bytes, 6, 2)
-
-    $hash = [System.Security.Cryptography.SHA1]::HashData($bytes + [System.Text.Encoding]::UTF8.GetBytes($Name))
-    $guid = $hash[0..15]
-    $guid[6] = ($guid[6] -band 0x0F) -bor 0x50
-    $guid[8] = ($guid[8] -band 0x3F) -bor 0x80
-
-    [array]::Reverse($guid, 0, 4)
-    [array]::Reverse($guid, 4, 2)
-    [array]::Reverse($guid, 6, 2)
-    [guid][byte[]]$guid
-}
-
-function Get-WixCommand {
-    $wix = Get-Command wix -ErrorAction SilentlyContinue
-    if (-not $wix) {
-        $candidate = Join-Path $env:USERPROFILE '.dotnet/tools/wix.exe'
-        if (Test-Path -LiteralPath $candidate) {
-            return $candidate
-        }
-        throw "wix not found. Install it with: dotnet tool install --global wix --version 5.0.2"
-    }
-    $wix.Source
-}
-
-$buildMsi = -not $MsiPath
-if ($buildMsi) {
-    if (-not $BinaryPath) {
-        $BinaryPath = Join-Path $RepoRoot '.pio/build/native-windows/meshtasticd.exe'
-    }
-    if (-not (Test-Path -LiteralPath $BinaryPath)) {
-        throw "meshtasticd.exe not found at '$BinaryPath'. Build it with 'platformio run -e native-windows' or pass -BinaryPath."
-    }
-    $BinaryPath = (Resolve-Path -LiteralPath $BinaryPath).Path
-
-    if (-not $SampleConfigPath) {
-        $SampleConfigPath = Join-Path $RepoRoot 'bin/config-dist.yaml'
-    }
-    if (-not (Test-Path -LiteralPath $SampleConfigPath)) {
-        throw "Sample config not found at '$SampleConfigPath'."
-    }
-    $SampleConfigPath = (Resolve-Path -LiteralPath $SampleConfigPath).Path
-} elseif (-not (Test-Path -LiteralPath $MsiPath)) {
-    throw "MSI not found at '$MsiPath'."
-} else {
-    $MsiPath = (Resolve-Path -LiteralPath $MsiPath).Path
-}
-
-$repoVersion = Get-RepoVersion -PropertiesPath (Join-Path $RepoRoot 'version.properties')
-$versionOverridden = $PSBoundParameters.ContainsKey('Version')
-if (-not $Version) { $Version = $repoVersion.Short }
-if (-not $ReleaseTag) {
-    # An overridden -Version must not keep the checkout's tag: the MSI would not be under it.
-    $ReleaseTag = if ($versionOverridden) { "v$Version" } else { "v$($repoVersion.Long)" }
-}
-if (-not $OutputDirectory) { $OutputDirectory = Join-Path $RepoRoot 'release/winget' }
-
-$msiName = if ($buildMsi) { "meshtasticd-$Version-$Architecture.msi" } else { Split-Path -Leaf $MsiPath }
-if (-not $InstallerUrl) {
-    $InstallerUrl = "https://github.com/meshtastic/firmware/releases/download/$ReleaseTag/$msiName"
-}
-
-$idParts = $PackageIdentifier.Split('.')
-if ($idParts.Count -lt 2) {
-    throw "PackageIdentifier '$PackageIdentifier' must be at least 'Publisher.Package'."
-}
-$manifestSegments = @('manifests', $idParts[0].Substring(0, 1).ToLowerInvariant()) + $idParts + @($Version)
-$manifestDir = Join-Path $OutputDirectory ($manifestSegments -join [IO.Path]::DirectorySeparatorChar)
-
-$null = New-Item -ItemType Directory -Path $OutputDirectory -Force
-$null = New-Item -ItemType Directory -Path $manifestDir -Force
-
-# Derived, not read back from the MSI, so -MsiPath produces the same value the build did.
-$productCode = (New-DeterministicGuid -Namespace $UpgradeCode -Name "$Version-$Architecture").ToString('B').ToUpperInvariant()
-
-if ($buildMsi) {
-    $msiPath = Join-Path $OutputDirectory $msiName
-    $wix = Get-WixCommand
-    & $wix build $WxsPath `
-        -arch $Architecture `
-        -ext WixToolset.Util.wixext `
-        -d Version=$Version `
-        -d ProductCode=$productCode `
-        -d BinaryPath=$BinaryPath `
-        -d ConfigPath=$SampleConfigPath `
-        -o $msiPath
-    if ($LASTEXITCODE -ne 0) {
-        throw "wix build failed with exit code $LASTEXITCODE. If the Util extension is missing: wix extension add -g WixToolset.Util.wixext/5.0.2"
-    }
-} else {
-    $msiPath = $MsiPath
-}
-
-$sha256 = (Get-FileHash -LiteralPath $msiPath -Algorithm SHA256).Hash
-$releaseDate = (Get-Date).ToString('yyyy-MM-dd')
-
-$versionManifest = @"
-# yaml-language-server: `$schema=https://aka.ms/winget-manifest.version.$ManifestVersion.schema.json
-
-PackageIdentifier: $PackageIdentifier
-PackageVersion: $Version
-DefaultLocale: en-US
-ManifestType: version
-ManifestVersion: $ManifestVersion
-"@
-
-$installerManifest = @"
-# yaml-language-server: `$schema=https://aka.ms/winget-manifest.installer.$ManifestVersion.schema.json
-
-PackageIdentifier: $PackageIdentifier
-PackageVersion: $Version
-MinimumOSVersion: 10.0.17763.0
-InstallerType: msi
-Scope: machine
-InstallModes:
-  - interactive
-  - silent
-  - silentWithProgress
-UpgradeBehavior: install
-ReleaseDate: $releaseDate
-Installers:
-  - Architecture: $Architecture
-    InstallerUrl: $InstallerUrl
-    InstallerSha256: $sha256
-    ProductCode: '$productCode'
-ManifestType: installer
-ManifestVersion: $ManifestVersion
-"@
-
-$localeManifest = @"
-# yaml-language-server: `$schema=https://aka.ms/winget-manifest.defaultLocale.$ManifestVersion.schema.json
-
-PackageIdentifier: $PackageIdentifier
-PackageVersion: $Version
-PackageLocale: en-US
-Publisher: Meshtastic
-PublisherUrl: https://meshtastic.org
-PublisherSupportUrl: https://github.com/meshtastic/firmware/issues
-PackageName: meshtasticd
-PackageUrl: https://github.com/meshtastic/firmware
-License: GPL-3.0-only
-LicenseUrl: https://github.com/meshtastic/firmware/blob/master/LICENSE
-ShortDescription: Meshtastic daemon for attached LoRa radio hardware
-Description: |-
-  meshtasticd is the native build of the Meshtastic firmware. It drives a LoRa radio attached
-  over SPI or a CH341 USB bridge and exposes the same TCP API as a Meshtastic device, so any
-  Meshtastic client can connect to it. Installs as an auto-starting Windows service reading
-  %ProgramData%\Meshtastic\config.yaml; without a radio configured there it runs in
-  simulated-radio mode.
-Moniker: meshtasticd
-Tags:
-  - daemon
-  - lora
-  - mesh
-  - meshtastic
-  - radio
-ReleaseNotesUrl: https://github.com/meshtastic/firmware/releases/tag/$ReleaseTag
-Documentations:
-  - DocumentLabel: Linux Native Docs
-    DocumentUrl: https://meshtastic.org/docs/software/linux/
-ManifestType: defaultLocale
-ManifestVersion: $ManifestVersion
-"@
-
-Set-Content -LiteralPath (Join-Path $manifestDir "$PackageIdentifier.yaml") -Value $versionManifest -Encoding utf8NoBOM
-Set-Content -LiteralPath (Join-Path $manifestDir "$PackageIdentifier.installer.yaml") -Value $installerManifest -Encoding utf8NoBOM
-Set-Content -LiteralPath (Join-Path $manifestDir "$PackageIdentifier.locale.en-US.yaml") -Value $localeManifest -Encoding utf8NoBOM
-
-Write-Host "Installer    $msiPath"
-Write-Host "SHA256       $sha256"
-Write-Host "ProductCode  $productCode"
-Write-Host "Manifests    $manifestDir"
-Write-Host "InstallerUrl $InstallerUrl"
-
-if ($Validate) {
-    $winget = Get-Command winget -ErrorAction SilentlyContinue
-    if (-not $winget) {
-        Write-Warning 'winget not found on PATH; skipping manifest validation.'
-    } else {
-        winget validate --manifest $manifestDir
-        if ($LASTEXITCODE -ne 0) {
-            throw "winget validate failed with exit code $LASTEXITCODE."
-        }
-    }
-}
-
-Write-Host ''
-Write-Host "Install locally (elevated):  msiexec /i `"$msiPath`" /qn"
-Write-Host "Then check:                  sc query meshtasticd"
-
-# The banner above goes to the host; callers get the same values on the pipeline.
-[pscustomobject]@{
-    Version           = $Version
-    ReleaseTag        = $ReleaseTag
-    Architecture      = $Architecture
-    MsiPath           = $msiPath
-    Sha256            = $sha256
-    ProductCode       = $productCode
-    InstallerUrl      = $InstallerUrl
-    ManifestDirectory = $manifestDir
-}

bin/check-all.sh

@@ -1,82 +1,26 @@
 #!/usr/bin/env bash
 
-# Run cppcheck static analysis over one or more PlatformIO environments.
-#
-# Why this is more than a bare `pio check`: the CI `check` matrix job in main_matrix.yml runs this
-# script inside meshtastic/gh-action-firmware, and `pio check` must download the platform package
-# before it can analyse anything. That download is regularly reset mid-flight by the CDN, e.g.
-#
-#   Checking station-g3 > cppcheck (board: station-g3; platform: .../platform-espressif32.zip)
-#   requests.exceptions.ConnectionError: ('Connection aborted.', ConnectionResetError(104, ...))
-#
-# The analysis never starts, so there is no signal at all - just a red X someone has to re-run by
-# hand. `pio check` exits 1 for that AND for real defects, so the exit code cannot tell them apart;
-# only the output can. This script classifies the failure:
-#
-#   * cppcheck produced results (summary table or defect lines) -> real, propagate the exit status.
-#   * transport-level network error and nothing else            -> warn and skip.
-#   * anything else                                             -> propagate the exit status.
-#
-# A missing or forbidden package (404 / UnknownPackageError / 403) is deliberately NOT treated as
-# transient: that is a reproducible break from a bad pin in a .ini, not weather.
-#
-# Exit codes: 0 = clean (or skipped under CI), 1 = defects/error, 2 = skipped locally.
+# Note: This is a prototype for how we could add static code analysis to the CI.
 
-set -uo pipefail
+set -e
 
-VERSION=$(bin/buildinfo.py long) || exit 1
+VERSION=$(bin/buildinfo.py long)
 
 # The shell vars the build tool expects to find
 export APP_VERSION=$VERSION
 
 if [[ $# -gt 0 ]]; then
 	# can override which environment by passing arg
-	BOARDS=("$@")
+	BOARDS="$@"
 else
-	BOARDS=(tlora-v2 tlora-v1 tlora_v1_3 tlora-v2-1-1.6 tbeam heltec-v2.0 heltec-v2.1 tbeam0.7 meshtastic-diy-v1 rak4631 rak4631_eink rak11200 t-echo canaryone pca10059_diy_eink)
+	BOARDS="tlora-v2 tlora-v1 tlora_v1_3 tlora-v2-1-1.6 tbeam heltec-v2.0 heltec-v2.1 tbeam0.7 meshtastic-diy-v1 rak4631 rak4631_eink rak11200 t-echo canaryone pca10059_diy_eink"
 fi
 
-echo "BOARDS:${BOARDS[*]}"
+echo "BOARDS:${BOARDS}"
 
-# Array, not a string: board names reach pio as literal arguments, so an override containing
-# whitespace or a glob character cannot turn into extra pio arguments.
-CHECK=()
-for BOARD in "${BOARDS[@]}"; do
-	CHECK+=(-e "${BOARD}")
+CHECK=""
+for BOARD in $BOARDS; do
+	CHECK="${CHECK} -e ${BOARD}"
 done
 
-LOG=$(mktemp)
-trap 'rm -f "$LOG"' EXIT
-
-# Keep streaming to the console so the CI log reads exactly as it did before; tee a copy for the
-# post-mortem classification below.
-pio check --flags "-DAPP_VERSION=${APP_VERSION} --suppressions-list=suppressions.txt --inline-suppr" "${CHECK[@]}" --skip-packages --pattern="src/" --fail-on-defect=low --fail-on-defect=medium --fail-on-defect=high 2>&1 | tee "$LOG"
-STATUS=${PIPESTATUS[0]}
-
-if [[ $STATUS -eq 0 ]]; then
-	exit 0
-fi
-
-# Fail closed: if cppcheck got far enough to report anything, the run is real no matter what other
-# noise is in the log.
-if grep -Eqi '^Component[[:space:]]+.*HIGH|^Total[[:space:]]+[0-9]|^[^[:space:]]+:[0-9]+: \[(high|medium|low)' "$LOG"; then
-	exit "$STATUS"
-fi
-
-# Transport-level failures only. No 403/404/UnknownPackageError here, on purpose.
-TRANSIENT='requests\.exceptions\.(ConnectionError|Timeout|ReadTimeout|ConnectTimeout)|ConnectionResetError|urllib3\.exceptions\.(ProtocolError|MaxRetryError|NameResolutionError|ReadTimeoutError)|Read timed out|Connection aborted|Connection refused|Temporary failure in name resolution|Could not resolve host|(429|500|502|503|504) (Server|Client) Error|Too Many Requests'
-
-if ! grep -Eq "$TRANSIENT" "$LOG"; then
-	exit "$STATUS"
-fi
-
-REASON=$(grep -Em1 "$TRANSIENT" "$LOG" | tr -d '\r' | cut -c1-200)
-
-echo "RESULT: SKIPPED ${BOARDS[*]} - transient network failure: ${REASON}"
-
-if [[ ${GITHUB_ACTIONS:-false} == "true" ]]; then
-	echo "::warning title=Static analysis skipped (${BOARDS[*]})::pio check could not download its packages: ${REASON}"
-	exit 0
-fi
-
-exit 2
+pio check --flags "-DAPP_VERSION=${APP_VERSION} --suppressions-list=suppressions.txt --inline-suppr" $CHECK --skip-packages --pattern="src/" --fail-on-defect=low --fail-on-defect=medium --fail-on-defect=high

bin/check-test-attribution.py

@@ -1,165 +0,0 @@
-#!/usr/bin/env python3
-"""Verify each PlatformIO JUnit report ran the suite it claims to have run.
-
-PlatformIO links every native test program to one path ($BUILD_DIR/$PROGNAME) and parses
-Unity output textually, without checking that the reported source file belongs to the suite
-it is running. Split a run into `--without-testing` then `--without-building` and every suite
-executes whichever binary was linked last, all reporting PASSED. This reads the JUnit reports
-that run already produces and fails on the two shapes that hides:
-
-  MISATTRIBUTED - a test case whose source file lives outside the suite that reported it
-  EMPTY         - a suite that was asked to run and produced no test cases at all
-
-Usage:
-  check-test-attribution.py [--expect "s1 s2"]... [--label TEXT] REPORT.xml...
-
---expect names the suites the run was asked for (repeatable, whitespace- or `-f`-separated,
-so a CI area string can be passed through verbatim). Omit it to check attribution only.
-Exit: 0 clean, 1 findings, 2 bad usage / unreadable report.
-"""
-
-import argparse
-import glob
-import sys
-import xml.etree.ElementTree as ET
-
-
-def parse_expect(values):
-    """Flatten repeated --expect values into a suite list, tolerating `-f suite` tokens."""
-    suites = []
-    for value in values or []:
-        for token in value.split():
-            if token == "-f":
-                continue
-            suites.append(token.removeprefix("-f"))
-    return [s for s in suites if s]
-
-
-def suite_of(testsuite_name):
-    """`coverage:test_foo` -> `test_foo`; a bare name is returned unchanged."""
-    return testsuite_name.split(":", 1)[1] if ":" in testsuite_name else testsuite_name
-
-
-def owns(suite, source_file):
-    """Report whether source_file sits inside the suite's own directory.
-
-    Matched on a whole path segment so `test_mesh` does not claim `test_mesh_module`, and
-    with a leading separator so absolute and relative paths behave the same.
-    """
-    normalized = "/" + source_file.replace("\\", "/").lstrip("/")
-    return f"/{suite}/" in normalized
-
-
-def collect(paths):
-    """Map suite -> list of (case name, source file or None), merged across reports."""
-    cases = {}
-    for path in paths:
-        try:
-            # The input is the JUnit report PlatformIO just wrote in this same run, not untrusted
-            # data, and defusedxml is not installed for this job.
-            # nosemgrep: python.lang.security.use-defused-xml-parse.use-defused-xml-parse
-            root = ET.parse(path).getroot()
-        except (ET.ParseError, OSError) as exc:
-            sys.stderr.write(f"check-test-attribution: cannot read {path}: {exc}\n")
-            sys.exit(2)
-        # PlatformIO nests <testsuite> under <testsuites>; accept a bare <testsuite> too.
-        nodes = [root] if root.tag == "testsuite" else root.iter("testsuite")
-        for node in nodes:
-            suite = suite_of(node.get("name", ""))
-            if not suite:
-                continue
-            entries = cases.setdefault(suite, [])
-            for case in node.iter("testcase"):
-                entries.append((case.get("name", "?"), case.get("file")))
-    return cases
-
-
-def main():
-    parser = argparse.ArgumentParser(add_help=True)
-    parser.add_argument("--expect", action="append", default=[])
-    parser.add_argument("--label", default="")
-    parser.add_argument("reports", nargs="+")
-    args = parser.parse_args()
-
-    # Expand globs ourselves: CI passes a pattern that may match nothing if a step was skipped,
-    # and a silent pass over zero reports is exactly the false green this script exists to stop.
-    paths = sorted({p for pattern in args.reports for p in glob.glob(pattern)})
-    if not paths:
-        sys.stderr.write(
-            "check-test-attribution: no JUnit reports matched %s\n"
-            % " ".join(args.reports)
-        )
-        return 2
-
-    cases = collect(paths)
-    expected = parse_expect(args.expect)
-
-    misattributed = []  # (suite, case name, source file)
-    unsourced = []  # (suite, case name)
-    for suite, entries in sorted(cases.items()):
-        for name, source in entries:
-            if source is None:
-                unsourced.append((suite, name))
-            elif not owns(suite, source):
-                misattributed.append((suite, name, source))
-
-    empty = [s for s in expected if not cases.get(s)]
-
-    label = f" [{args.label}]" if args.label else ""
-    total = sum(len(v) for v in cases.values())
-    print(
-        f"test attribution{label}: {len(paths)} report(s), "
-        f"{len([s for s, v in cases.items() if v])} suite(s) with cases, {total} case(s)"
-    )
-    if unsourced:
-        print("")
-        print("UNSOURCED - these cases carry no source file, so ownership cannot be proved:")
-        for suite, name in unsourced[:20]:
-            print(f"    {suite}: case '{name}'")
-        if len(unsourced) > 20:
-            print(f"    ... +{len(unsourced) - 20} more")
-        print(
-            "A report without file attributes is not evidence that the suites ran their own"
-        )
-        print(
-            "tests. Treat it as a finding rather than a pass: the JUnit format has changed, or"
-        )
-        print("the runner emitted cases it could not attribute.")
-
-    if misattributed:
-        print("")
-        print(
-            "MISATTRIBUTED - these suites reported test cases belonging to another suite."
-        )
-        print(
-            "The run executed one suite's binary under another suite's name; the named"
-        )
-        print(
-            "suites did NOT run. Check for --without-building in the test invocation."
-        )
-        for suite, name, source in misattributed[:20]:
-            print(f"    {suite}: case '{name}' came from {source}")
-        if len(misattributed) > 20:
-            print(f"    ... +{len(misattributed) - 20} more")
-
-    if empty:
-        print("")
-        print("EMPTY - these suites were asked to run and produced no test cases:")
-        for suite in empty:
-            print(f"    {suite}")
-
-    if misattributed or empty or unsourced:
-        print("")
-        print(
-            "RESULT: test attribution FAILED"
-            f"{label} ({len(misattributed)} misattributed, {len(empty)} empty,"
-            f" {len(unsourced)} unsourced)"
-        )
-        return 1
-
-    print(f"RESULT: test attribution OK{label}")
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

bin/collect_sizes.py

@@ -1,77 +0,0 @@
-#!/usr/bin/env python3
-
-"""Collect firmware binary sizes from manifest (.mt.json) files into a single report.
-
-Output schema (consumed by bin/size_report.py):
-    {"<env>": {"flash_bytes": <int>, "ram_bytes": <int>}}
-
-flash_bytes is the size of the main firmware image (.bin); for targets whose
-packaged artifacts include no raw .bin (e.g. nRF52) it falls back to the
-flash_bytes value (ELF text + data) emitted into the manifest by
-bin/platformio-custom.py. ram_bytes is the static RAM footprint (.data + .bss)
-emitted into the manifest by bin/platformio-custom.py; either metric is
-omitted for manifests that predate it, and size_report.py renders those as
-"n/a".
-"""
-
-import json
-import os
-import sys
-
-
-def collect_sizes(manifest_dir):
-    """Scan manifest_dir for .mt.json files and return {board: sizes_dict}."""
-    sizes = {}
-    for fname in sorted(os.listdir(manifest_dir)):
-        if not fname.endswith(".mt.json"):
-            continue
-        path = os.path.join(manifest_dir, fname)
-        with open(path) as f:
-            data = json.load(f)
-        board = data.get("platformioTarget", fname.replace(".mt.json", ""))
-        # Find the main firmware .bin size (largest .bin, excluding OTA/littlefs/bleota)
-        bin_size = None
-        for entry in data.get("files", []):
-            name = entry.get("name", "")
-            if name.startswith("firmware-") and name.endswith(".bin"):
-                bin_size = entry["bytes"]
-                break
-        # Fallback: any .bin that isn't ota/littlefs/bleota
-        if bin_size is None:
-            for entry in data.get("files", []):
-                name = entry.get("name", "")
-                if name.endswith(".bin") and not any(
-                    x in name for x in ["littlefs", "bleota", "ota"]
-                ):
-                    bin_size = entry["bytes"]
-                    break
-        # Fallback: flash footprint emitted into the manifest (ELF text + data),
-        # for targets that package no raw .bin (e.g. nRF52 hex/uf2/DFU zip)
-        if bin_size is None:
-            flash_bytes = data.get("flash_bytes")
-            if isinstance(flash_bytes, int) and not isinstance(flash_bytes, bool):
-                bin_size = flash_bytes
-        entry = {}
-        if bin_size is not None:
-            entry["flash_bytes"] = bin_size
-        ram_bytes = data.get("ram_bytes")
-        if isinstance(ram_bytes, int) and not isinstance(ram_bytes, bool):
-            entry["ram_bytes"] = ram_bytes
-        if entry:
-            sizes[board] = entry
-    return sizes
-
-
-if __name__ == "__main__":
-    if len(sys.argv) != 3:
-        print(f"Usage: {sys.argv[0]} <manifest_dir> <output.json>", file=sys.stderr)
-        sys.exit(1)
-
-    manifest_dir = sys.argv[1]
-    output_path = sys.argv[2]
-
-    sizes = collect_sizes(manifest_dir)
-    with open(output_path, "w") as f:
-        json.dump(sizes, f, indent=2, sort_keys=True)
-
-    print(f"Collected sizes for {len(sizes)} targets -> {output_path}")

bin/config-dist.yaml

@@ -104,9 +104,7 @@ Lora:
 ### Define GPS
 
 GPS:
-#  SerialPath: /dev/ttyS0  # Use a physical serial GPS device (mutually exclusive with GpsdHost)
-#  GpsdHost: localhost      # Use gpsd daemon as GPS source instead of a serial device
-#  GpsdPort: 2947           # gpsd TCP port (default: 2947)
+#  SerialPath: /dev/ttyS0
 #  ExtraPins:
 #    - 22
 
@@ -153,30 +151,6 @@ Display:
 ### You can also specify the spi device for the display to use
 # spidev: spidev0.0
 
-### HUB75 RGB LED matrix panel (Raspberry Pi only, via hzeller/rpi-rgb-led-matrix).
-### Requires the librgbmatrix library to be installed (so `pkg-config rgbmatrix` resolves) and
-### the firmware built with it present. meshtasticd must run as root (or with /dev/gpiomem
-### access) and on-board audio disabled (dtparam=audio=off) so it doesn't fight the PWM timing.
-### The library owns the GPIO pins - they are chosen by HardwareMapping, not set individually.
-#  Panel: HUB75
-#  HUB75:
-#    HardwareMapping: adafruit-hat-pwm  # regular | adafruit-hat | adafruit-hat-pwm | regular-pi1 ...
-#    Rows: 64                # pixel rows per panel (e.g. 32 or 64)
-#    Cols: 64                # pixel columns per panel
-#    ChainLength: 1          # panels daisy-chained (width = Cols * ChainLength)
-#    Parallel: 1             # parallel chains (height = Rows * Parallel)
-#    Brightness: 80          # percent, 1..100
-#    PWMBits: 11             # lower = higher refresh, fewer colors
-#    GPIOSlowdown: 4         # raise for faster Pis / long cables if the panel ghosts or flickers
-#    RGBSequence: RGB        # reorder if your panel's colors are swapped (e.g. RBG, BGR)
-#    ScanMode: 0             # 0=progressive, 1=interlaced
-#    RowAddressType: 0       # 0=default, 1=AB-addressed (some 64x64 panels)
-#    Multiplexing: 0         # 0=direct, 1=stripe, 2=checker, ...
-#    PanelType: ""           # e.g. FM6126A for panels needing a special init
-#    PixelMapper: ""         # e.g. "U-mapper;Rotate:90"
-#    LimitRefreshRateHz: 0   # 0 = no limit
-#    DisableHardwarePulsing: false
-
 Touchscreen:
 ### Note, at least for now, the touchscreen must have a CS pin defined, even if you let Linux manage the CS switching.
 
@@ -191,21 +165,12 @@ Touchscreen:
 ### You can also specify the spi device for the touchscreen to use
 # spidev: spidev0.0
 
+
 Input:
 ### Configure device for direct keyboard input
 
 #  KeyboardDevice: /dev/input/by-id/usb-_Raspberry_Pi_Internal_Keyboard-event-kbd
 
-### Configure device for USB gamepad/joystick input (evdev). The D-pad drives
-### Up/Down/Left/Right; buttons are mapped below. Find button codes with `evtest`.
-#  JoystickDevice: /dev/input/by-id/usb-0079_USB_Gamepad-event-joystick
-### Map evdev button codes (hex or decimal) to actions. Omit to use built-in
-### defaults (select=0x121, cancel=0x122). Actions: select, cancel, back, up,
-### down, left, right, user.
-#  JoystickButtons:
-#    select: 0x122
-#    cancel: 0x121
-
 ### Standard User Button Config
 #  UserButton: 6
 
@@ -232,11 +197,13 @@ Webserver:
 #  SSLKey: /etc/meshtasticd/ssl/private_key.pem # Path to SSL Key, generated if not present
 #  SSLCert: /etc/meshtasticd/ssl/certificate.pem # Path to SSL Certificate, generated if not present
 
+
 HostMetrics:
 #  ReportInterval: 30 # Interval in minutes between HostMetrics report packets, or 0 for disabled
 #  Channel: 0 # channel to send Host Metrics over. Defaults to the primary channel.
 #  UserStringCommand: cat /sys/firmware/devicetree/base/serial-number # Command to execute, to send the results as the userString
 
+
 Config:
 #  DisplayMode: TWOCOLOR # uncomment to force BaseUI
 #  DisplayMode: COLOR # uncomment to force MUI

bin/config.d/display-hub75-64x64.yaml

@@ -1,37 +0,0 @@
-Meta:
-  name: HUB75 RGB LED Matrix (64x64)
-  support: community
-  compatible:
-    - raspberry-pi
-
-### HUB75 RGB LED matrix panel driven by hzeller/rpi-rgb-led-matrix.
-###
-### Prerequisites:
-###   - Install the rpi-rgb-led-matrix library so `pkg-config rgbmatrix` resolves, and build the
-###     firmware with it present (the HUB75 backend is compiled in automatically when found).
-###   - meshtasticd must run as root (or have /dev/gpiomem access) for the library's direct GPIO.
-###   - Disable on-board audio (dtparam=audio=off in /boot/firmware/config.txt) - it shares the
-###     PWM hardware and causes flicker otherwise.
-###
-### The library owns the GPIO pins; they are selected by HardwareMapping (matching your HAT /
-### wiring), not assigned individually.
-Display:
-  Panel: HUB75
-  HUB75:
-    HardwareMapping: adafruit-hat-pwm
-    Rows: 64
-    Cols: 64
-    ChainLength: 1
-    Parallel: 1
-    Brightness: 80
-    PWMBits: 11
-    GPIOSlowdown: 4
-    RGBSequence: RGB
-    # Uncomment/tune as needed for your specific panel:
-    # ScanMode: 0
-    # RowAddressType: 0
-    # Multiplexing: 0
-    # PanelType: FM6126A
-    # PixelMapper: ""
-    # LimitRefreshRateHz: 0
-    # DisableHardwarePulsing: false

bin/config.d/femtofox/femtofox_E80-900M2213S.yaml

@@ -1,31 +0,0 @@
----
-Lora:
-  ## Ebyte E80-900M2213S
-  ## This is a bit experimental
-  ##
-  ##
-  Module: lr1121
-  gpiochip: 1 # subtract 32 from the gpio numbers
-  DIO3_TCXO_VOLTAGE: 1.8
-  CS: 16 #pin6 / GPIO48 1C0
-  IRQ: 23 #pin17 / GPIO55 1C7
-  Busy: 22 #pin16 / GPIO54 1C6
-  Reset: 25 #pin13 / GPIO57 1D1
-
-  spidev: spidev0.0 #pins are (CS=16, CLK=17, MOSI=18, MISO=19)
-  spiSpeed: 2000000
-
-  # CDEbyte do not follow the Semtech reference switching: DIO5/DIO6 are swapped.
-  # DIO7 is wired to the GNSS path. See variants/nrf52840/diy/nrf52_promicro_diy_tcxo/readme.md
-  rfswitch_table:
-    pins: [DIO5, DIO6, DIO7]
-    MODE_STBY: [LOW, LOW, LOW]
-    MODE_RX: [LOW, HIGH, LOW]
-    MODE_TX: [HIGH, HIGH, LOW]
-    MODE_TX_HP: [HIGH, LOW, LOW]
-    MODE_TX_HF: [LOW, LOW, LOW]
-    MODE_GNSS: [LOW, LOW, HIGH]
-    MODE_WIFI: [LOW, LOW, LOW]
-
-General:
-  MACAddressSource: eth0

bin/config.d/femtofox/femtofox_LR1121 generic.yaml

@@ -1,28 +0,0 @@
----
-Lora:
-  ## Generic LR1121 module (Semtech reference RF switch topology)
-  ## This is a bit experimental
-  Module: lr1121
-  gpiochip: 1 # subtract 32 from the gpio numbers
-  DIO3_TCXO_VOLTAGE: 1.8
-  CS: 16 #pin6 / GPIO48 1C0
-  IRQ: 23 #pin17 / GPIO55 1C7
-  Busy: 22 #pin16 / GPIO54 1C6
-  Reset: 25 #pin13 / GPIO57 1D1
-
-  spidev: spidev0.0 #pins are (CS=16, CLK=17, MOSI=18, MISO=19)
-  spiSpeed: 2000000
-
-  # Semtech reference switching (SWSD006): rx=RFSW0, tx=RFSW0|RFSW1, tx_hp=RFSW1.
-  rfswitch_table:
-    pins: [DIO5, DIO6]
-    MODE_STBY: [LOW, LOW]
-    MODE_RX: [HIGH, LOW]
-    MODE_TX: [HIGH, HIGH]
-    MODE_TX_HP: [LOW, HIGH]
-    MODE_TX_HF: [LOW, LOW]
-    MODE_GNSS: [LOW, LOW]
-    MODE_WIFI: [LOW, LOW]
-
-General:
-  MACAddressSource: eth0

bin/config.d/femtofox/femtofox_WIO-LR1121.yaml

@@ -1,37 +0,0 @@
----
-Lora:
-  ## Seeed Wio-LR1121
-  ## This is a bit experimental
-  Module: lr1121
-  gpiochip: 1 # subtract 32 from the gpio numbers
-  DIO3_TCXO_VOLTAGE: 1.8
-  CS: 16 #pin6 / GPIO48 1C0
-  IRQ: 23 #pin17 / GPIO55 1C7
-  Busy: 22 #pin16 / GPIO54 1C6
-  Reset: 25 #pin13 / GPIO57 1D1
-
-  spidev: spidev0.0 #pins are (CS=16, CLK=17, MOSI=18, MISO=19)
-  spiSpeed: 2000000
-
-  # Internal RF switch is a Skyworks SKY13373-460LF driven by DIO5 (V1) and DIO6 (V2).
-  # Datasheet section 4.5 "True Table of the Internal RF Switch":
-  #   V1 V2  Status
-  #    0  0  Shutdown            -> MODE_STBY
-  #    1  0  RFI_P_LF & RFI_N_LF -> MODE_RX
-  #    0  1  RFO_HP_LF           -> MODE_TX_HP
-  #    1  1  RFO_LP_LF           -> MODE_TX
-  # This matches the Semtech reference topology (SWSD006):
-  # rx=RFSW0, tx=RFSW0|RFSW1, tx_hp=RFSW1.
-  # The LR1121 has no GNSS/WiFi scanning, so those modes are unused.
-  rfswitch_table:
-    pins: [DIO5, DIO6]
-    MODE_STBY: [LOW, LOW]
-    MODE_RX: [HIGH, LOW]
-    MODE_TX: [HIGH, HIGH]
-    MODE_TX_HP: [LOW, HIGH]
-    MODE_TX_HF: [LOW, LOW]
-    MODE_GNSS: [LOW, LOW]
-    MODE_WIFI: [LOW, LOW]
-
-General:
-  MACAddressSource: eth0

bin/config.d/lora-FrameTastic-1262.yaml

@@ -1,20 +0,0 @@
-#copy of lora-meshstick-1262.yaml data changed to match FrameTastic 1262 board
-
-Meta:
-  name: FrameTastic 1262
-  support: community
-  compatible:
-    - usb
-
-
-Lora:
-  Module: sx1262
-  CS: 0
-  IRQ: 6
-  Reset: 2
-  Busy: 4
-  spidev: ch341
-  DIO3_TCXO_VOLTAGE: true
-#  USB_Serialnum: 12345678
-  USB_PID: 0x5512
-  USB_VID: 0x1A86

bin/config.d/lora-NebraHat_1W.yaml

@@ -1,19 +0,0 @@
-# https://github.com/wehooper4/Meshtastic-Hardware/tree/main/NebraHat
-# Use for 1 watt hat
-Meta:
-  name: NebraHat 1W
-  support: community
-  compatible:
-    - raspberry-pi
-
-Lora:
-  Module: sx1262  # Nebra SX1262 Pi Hat - 1W
-  DIO2_AS_RF_SWITCH: true
-  DIO3_TCXO_VOLTAGE: true
-#  CS: 8          # Newer version of MeshtasticD do not need this? If issues uncomment this line
-  IRQ: 22
-  Busy: 4
-  Reset: 18
-  RXen: 25  
-I2C:
-  I2CDevice: /dev/i2c-1

bin/config.d/lora-NebraHat_2W.yaml

@@ -1,20 +0,0 @@
-# https://github.com/wehooper4/Meshtastic-Hardware/tree/main/NebraHat
-# Use for 2 watt hat
-Meta:
-  name: NebraHat 2W
-  support: community
-  compatible:
-    - raspberry-pi
-
-Lora:
-  Module: sx1262  # Nebra SX1262 Pi Hat - 2W
-  DIO2_AS_RF_SWITCH: true
-  DIO3_TCXO_VOLTAGE: true
-  SX126X_MAX_POWER: 8
-#  CS: 8          # Newer version of MeshtasticD do not need this? If issues uncomment this line
-  IRQ: 22
-  Busy: 4
-  Reset: 18
-  RXen: 25
-I2C:
-  I2CDevice: /dev/i2c-1

bin/config.d/lora-PiTastic-1W.yaml

@@ -1,20 +0,0 @@
-#Board uses wehoopers zebra hat config # https://github.com/wehooper4/Meshtastic-Hardware/tree/main/ZebraHAT
-
-Meta:
-  name: PiTastic 1W
-  support: community
-  compatible:
-    - raspberry-pi
-
-Lora:
-  Module: sx1262
-  DIO2_AS_RF_SWITCH: true
-  DIO3_TCXO_VOLTAGE: true
-  SX126X_MAX_POWER: 18 
-  CS: 24
-  IRQ: 22
-  Busy: 27
-  Reset: 17
-
-I2C:
-  I2CDevice: /dev/i2c-1

bin/config.d/lora-RAK6421-13300-slot1.yaml

@@ -18,4 +18,4 @@ Lora:
   DIO3_TCXO_VOLTAGE: true
   DIO2_AS_RF_SWITCH: true
   spidev: spidev0.0
-  # CS: 8
+  # CS: 8

bin/config.d/lora-RAK6421-13300-slot2.yaml

@@ -5,9 +5,7 @@ Meta:
     - raspberry-pi
 
 Lora:
-  
-  ### RAK13300 in Slot 2
-  Module: sx1262
+  ### RAK13300 in Slot 2 pins
   IRQ: 18 #IO6
   Reset: 24 # IO4
   Busy: 19 # IO5
@@ -15,7 +13,5 @@ Lora:
   Enable_Pins:
     - 26
     - 23
-  DIO3_TCXO_VOLTAGE: true
-  DIO2_AS_RF_SWITCH: true
   spidev: spidev0.1
-  # CS: 7
+  # CS: 7

bin/config.d/lora-RAK6421-13302-slot2.yaml

@@ -5,18 +5,14 @@ Meta:
     - raspberry-pi
 
 Lora:
-
-  ### RAK13302 in Slot 2
-  Module: sx1262
+  ### RAK13302 in Slot 2 pins
   IRQ: 18 #IO6
   Reset: 24 # IO4
   Busy: 19 # IO5
-  # Ant_sw: 23 # IO3
+  # Ant_sw: 23 # IO3 
   Enable_Pins:
     - 26
     - 23
-  DIO3_TCXO_VOLTAGE: true
-  DIO2_AS_RF_SWITCH: true
   spidev: spidev0.1
   # CS: 7
   TX_GAIN_LORA: [9, 9, 10, 11, 9, 8, 9, 10, 10, 10, 11, 12, 12, 12, 12, 12, 12, 12, 12, 10, 9, 8]

bin/config.d/lora-ZebraHat_1W.yaml

@@ -1,19 +0,0 @@
-# https://github.com/wehooper4/Meshtastic-Hardware/tree/main/ZebraHAT
-# Use for 1 watt hat
-Meta:
-  name: ZebraHat 1W
-  support: community
-  compatible:
-    - raspberry-pi
-
-Lora:
-  Module: sx1262  # Zebra SX1262 Pi Hat - 1W
-  DIO2_AS_RF_SWITCH: true
-  DIO3_TCXO_VOLTAGE: true
-  SX126X_MAX_POWER: 18 
-  CS: 24
-  IRQ: 22
-  Busy: 27
-  Reset: 17
-I2C:
-  I2CDevice: /dev/i2c-1

bin/config.d/lora-ZebraHat_2W.yaml

@@ -1,20 +0,0 @@
-# https://github.com/wehooper4/Meshtastic-Hardware/tree/main/ZebraHAT
-# Use for 2 watt hat
-Meta:
-  name: ZebraHat 2W
-  support: community
-  compatible:
-    - raspberry-pi
-
-Lora:
-  Module: sx1262  # Zebra SX1262 Pi Hat - 2W
-  DIO2_AS_RF_SWITCH: true
-  DIO3_TCXO_VOLTAGE: true
-  SX126X_MAX_POWER: 8 
-  CS: 24
-  IRQ: 22
-  Busy: 27
-  Reset: 17
-  RXen: 25
-I2C:
-  I2CDevice: /dev/i2c-1

bin/config.d/lora-ecb41-pge-RAK6421-13300-slot2.yaml

@@ -29,8 +29,6 @@ Lora:
     - pin: 50 # GPIO1_C2 (physical 16)
       gpiochip: 1
       line: 18
-  DIO3_TCXO_VOLTAGE: true
-  DIO2_AS_RF_SWITCH: true
   spidev: spidev0.1
   # CS: # GPIO0_A7 (SPI1_CSN1, physical 26)
   #   pin: 7

bin/config.d/lora-ecb41-pge-RAK6421-13302-slot2.yaml

@@ -29,8 +29,6 @@ Lora:
     - pin: 50 # GPIO1_C2 (physical 16)
       gpiochip: 1
       line: 18
-  DIO3_TCXO_VOLTAGE: true
-  DIO2_AS_RF_SWITCH: true
   spidev: spidev0.1
   # CS: # GPIO0_A7 (SPI1_CSN1, physical 26)
   #   pin: 7

bin/config.d/lora-lyra-zero-BQ-SG3-BQ35LORA900V1M-slot1.yaml

@@ -1,29 +0,0 @@
-# Station G3 + BQ35LORA900V1M Primary Slot
-# Board Doc: https://wiki.bqvoy.com/en/devkits/station-g3
-Meta:
-  name: B&Q Station G3 + BQ35LORA900V1M Primary Slot
-  support: official
-  compatible:
-    - luckfox-lyra-zero-w # Armbian
-
-Lora:
-  Module: sx1262
-  IRQ: # GPIO0_A5 (physical 15)
-    pin: 5
-    gpiochip: 0
-    line: 5
-  Reset: # GPIO1_D1 (physical 36)
-    pin: 57
-    gpiochip: 1
-    line: 25
-  Busy: # GPIO0_B4 (physical 18)
-    pin: 12
-    gpiochip: 0
-    line: 12
-  DIO3_TCXO_VOLTAGE: true
-  DIO2_AS_RF_SWITCH: true
-  spidev: spidev0.0
-  # CS: # GPIO0_B2 (physical 24)
-  #   pin: 10
-  #   gpiochip: 0
-  #   line: 10

bin/config.d/lora-lyra-zero-RAK6421-13300-slot2.yaml

@@ -29,8 +29,6 @@ Lora:
     - pin: 13 # GPIO0_B5
       gpiochip: 0
       line: 13
-  DIO3_TCXO_VOLTAGE: true
-  DIO2_AS_RF_SWITCH: true
   spidev: spidev0.1
   # CS: # GPIO0_B1
   #   pin: 9

bin/config.d/lora-lyra-zero-RAK6421-13302-slot2.yaml

@@ -29,8 +29,6 @@ Lora:
     - pin: 13 # GPIO0_B5
       gpiochip: 0
       line: 13
-  DIO3_TCXO_VOLTAGE: true
-  DIO2_AS_RF_SWITCH: true
   spidev: spidev0.1
   # CS: # GPIO0_B1
   #   pin: 9

bin/config.d/lora-ok3506-RAK6421-13300-slot2.yaml

@@ -31,8 +31,6 @@ Lora:
     - pin: 103 # GPIO3_A7 (physical 16)
       gpiochip: 3
       line: 7
-  DIO3_TCXO_VOLTAGE: true
-  DIO2_AS_RF_SWITCH: true
   spidev: spidev0.1
   # CS: # GPIO0_B7 (SPI0_CSN1, physical 26)
   #   pin: 15

bin/config.d/lora-ok3506-RAK6421-13302-slot2.yaml

@@ -31,8 +31,6 @@ Lora:
     - pin: 103 # GPIO3_A7 (physical 16)
       gpiochip: 3
       line: 7
-  DIO3_TCXO_VOLTAGE: true
-  DIO2_AS_RF_SWITCH: true
   spidev: spidev0.1
   # CS: # GPIO0_B7 (SPI0_CSN1, physical 26)
   #   pin: 15

bin/config.d/lora-piggystick-lr1121.yaml

@@ -1,5 +1,5 @@
 Meta:
-  name: PiggyStick LR1121
+  name: Lora Meshstick SX1262
   support: community
   compatible:
     - usb
@@ -12,6 +12,6 @@ Lora:
   Busy: 4
   spidev: ch341
   DIO3_TCXO_VOLTAGE: 1.8
-  #  USB_Serialnum: 12345678
+#  USB_Serialnum: 12345678
   USB_PID: 0x5512
   USB_VID: 0x1A86

bin/config.d/lora-pimesh-1w-v1.yaml

@@ -1,21 +0,0 @@
-# PiMesh-1W (V1) E22-900M30S
-# https://meshsmith.net/products/pimesh-1w
-Meta:
-  name: PiMesh-1W (V1) E22-900M30S
-  support: community
-  compatible:
-    - raspberry-pi
-    
-Lora:
-  Module: sx1262
-  CS: 21
-  IRQ: 16
-  Reset: 18
-  Busy: 20
-  TXen: 13
-  RXen: 12
-  DIO3_TCXO_VOLTAGE: true
-  SX126X_MAX_POWER: 22
-  spidev: spidev0.0
-
-# preamble_length: 17

bin/config.d/lora-pimesh-1w-v2.yaml

@@ -1,21 +0,0 @@
-# PiMesh-1W (V2) E22P-915M30S / E22P-868M30S
-# https://meshsmith.net/products/pimesh-1w
-Meta:
-  name: PiMesh-1W (V2) E22P-915M30S / E22P-868M30S
-  support: community
-  compatible:
-    - raspberry-pi
-
-Lora:
-  Module: sx1262
-  IRQ: 6
-  Reset: 18
-  Busy: 5
-  CS: 8
-  DIO2_AS_RF_SWITCH: true
-  DIO3_TCXO_VOLTAGE: true
-  SX126X_MAX_POWER: 22
-  spidev: spidev0.0
-
-# add the following to /boot/firmware/config.txt
-# gpio=26=op,dh

bin/config.d/lora-rpi-BQ-SG3-BQ35LORA900V1M-slot1.yaml

@@ -1,17 +0,0 @@
-# Station G3 + BQ35LORA900V1M Primary Slot
-# Board Doc: https://wiki.bqvoy.com/en/devkits/station-g3
-Meta:
-  name: B&Q Station G3 + BQ35LORA900V1M Primary Slot
-  support: official
-  compatible:
-    - raspberry-pi
-
-Lora:
-  Module: sx1262
-  IRQ: 22
-  Reset: 16
-  Busy: 24
-  DIO3_TCXO_VOLTAGE: true
-  DIO2_AS_RF_SWITCH: true
-  spidev: spidev0.0
-  #CS: 8

bin/config.d/lora-usb-meshtoad-e22.yaml

@@ -1,5 +1,3 @@
-# This config works with all revisions of the Meshtoad USB radio.
-
 Meta:
   name: meshtoad-e22
   support: official