Extract validateAdvertSignature to shared package, accept []byte, add server tests

- Extract signature validation to internal/sigvalidate/ shared package
- Change function signature to accept []byte instead of hex strings,
  eliminating unnecessary hex encode/decode round-trip
- Add signature validation tests to cmd/server/decoder_test.go
- Both cmd/server and cmd/ingestor now import from the shared package

Addresses all review feedback on PR #686.

.github/workflows/deploy.yml

@@ -3,10 +3,15 @@ name: CI/CD Pipeline
 on:
   push:
     branches: [master]
+    tags: ['v*']
   pull_request:
     branches: [master]
   workflow_dispatch:
 
+permissions:
+  contents: read
+  packages: write
+
 concurrency:
   group: ci-${{ github.event.pull_request.number || github.ref }}
   cancel-in-progress: true
@@ -18,8 +23,8 @@ env:
   STAGING_CONTAINER: corescope-staging-go
 
 # Pipeline (sequential, fail-fast):
-#   go-test → e2e-test → build → deploy → publish
-#   PRs stop after build. Master continues to deploy + publish.
+#   go-test → e2e-test → build-and-publish → deploy → publish-badges
+#   PRs stop after build-and-publish (no GHCR push). Master continues to deploy + badges.
 
 jobs:
   # ───────────────────────────────────────────────────────────────
@@ -231,51 +236,108 @@ jobs:
           include-hidden-files: true
 
   # ───────────────────────────────────────────────────────────────
-  # 3. Build Docker Image
+  # 3. Build & Publish Docker Image
   # ───────────────────────────────────────────────────────────────
-  build:
-    name: "🏗️ Build Docker Image"
+  build-and-publish:
+    name: "🏗️ Build & Publish Docker Image"
     needs: [e2e-test]
-    runs-on: [self-hosted, Linux]
+    runs-on: [self-hosted, meshcore-runner-2]
     steps:
       - name: Checkout code
         uses: actions/checkout@v5
 
-      - name: Set up Node.js 22
-        uses: actions/setup-node@v5
-        with:
-          node-version: '22'
-
       - name: Free disk space
         run: |
           docker system prune -af 2>/dev/null || true
           docker builder prune -af 2>/dev/null || true
           df -h /
 
-      - name: Build Go Docker image
+      - name: Compute build metadata
+        id: meta
         run: |
-          echo "${GITHUB_SHA::7}" > .git-commit
-          APP_VERSION=$(node -p "require('./package.json').version") \
-          GIT_COMMIT="${GITHUB_SHA::7}" \
-          APP_VERSION=$(grep -oP 'APP_VERSION:-\K[^}]+' docker-compose.yml | head -1 || echo "3.0.0")
-          GIT_COMMIT=$(git rev-parse --short HEAD)
           BUILD_TIME=$(date -u '+%Y-%m-%dT%H:%M:%SZ')
-          export APP_VERSION GIT_COMMIT BUILD_TIME
+          GIT_COMMIT="${GITHUB_SHA::7}"
+          if [[ "$GITHUB_REF" == refs/tags/v* ]]; then
+            APP_VERSION="${GITHUB_REF#refs/tags/}"
+          else
+            APP_VERSION="edge"
+          fi
+          echo "build_time=$BUILD_TIME" >> "$GITHUB_OUTPUT"
+          echo "git_commit=$GIT_COMMIT" >> "$GITHUB_OUTPUT"
+          echo "app_version=$APP_VERSION" >> "$GITHUB_OUTPUT"
+          echo "Build: version=$APP_VERSION commit=$GIT_COMMIT time=$BUILD_TIME"
+
+      - name: Build Go Docker image (local staging)
+        run: |
+          GIT_COMMIT="${{ steps.meta.outputs.git_commit }}" \
+          APP_VERSION="${{ steps.meta.outputs.app_version }}" \
+          BUILD_TIME="${{ steps.meta.outputs.build_time }}" \
           docker compose -f "$STAGING_COMPOSE_FILE" -p corescope-staging build "$STAGING_SERVICE"
           echo "Built Go staging image ✅"
 
+      - name: Set up Docker Buildx
+        if: github.event_name == 'push'
+        uses: docker/setup-buildx-action@v3
+
+      - name: Log in to GHCR
+        if: github.event_name == 'push'
+        uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Extract Docker metadata
+        if: github.event_name == 'push'
+        id: docker-meta
+        uses: docker/metadata-action@v5
+        with:
+          images: ghcr.io/kpa-clawbot/corescope
+          tags: |
+            type=semver,pattern=v{{version}}
+            type=semver,pattern=v{{major}}.{{minor}}
+            type=semver,pattern=v{{major}}
+            type=raw,value=latest,enable=${{ startsWith(github.ref, 'refs/tags/v') }}
+            type=edge,branch=master
+
+      - name: Build and push to GHCR
+        if: github.event_name == 'push'
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          push: true
+          platforms: linux/amd64
+          tags: ${{ steps.docker-meta.outputs.tags }}
+          labels: ${{ steps.docker-meta.outputs.labels }}
+          build-args: |
+            APP_VERSION=${{ steps.meta.outputs.app_version }}
+            GIT_COMMIT=${{ steps.meta.outputs.git_commit }}
+            BUILD_TIME=${{ steps.meta.outputs.build_time }}
+          cache-from: type=gha
+          cache-to: type=gha,mode=max
+
   # ───────────────────────────────────────────────────────────────
   # 4. Deploy Staging (master only)
   # ───────────────────────────────────────────────────────────────
   deploy:
     name: "🚀 Deploy Staging"
     if: github.event_name == 'push'
-    needs: [build]
-    runs-on: [self-hosted, Linux]
+    needs: [build-and-publish]
+    runs-on: [self-hosted, meshcore-runner-2]
     steps:
       - name: Checkout code
         uses: actions/checkout@v5
 
+      - name: Pull latest image from GHCR
+        run: |
+          # Try to pull the edge image from GHCR and tag for docker-compose compatibility
+          if docker pull ghcr.io/kpa-clawbot/corescope:edge; then
+            docker tag ghcr.io/kpa-clawbot/corescope:edge corescope-go:latest
+            echo "Pulled and tagged GHCR edge image ✅"
+          else
+            echo "⚠️ GHCR pull failed — falling back to locally built image"
+          fi
+
       - name: Deploy staging
         run: |
           # Stop old container and release memory

AGENTS.md

@@ -362,6 +362,12 @@ One logical change per commit. Each commit is deployable. Each commit has its te
 - Tests: `test-{feature}.js` in repo root
 - No build step, no transpilation — write ES2020 for server, ES5/6 for frontend (broad browser support)
 
+### Deep Linking
+All new UI states that a user might want to share or bookmark MUST be reflected in the URL hash.
+This includes: tabs, filters, selected items, view modes. Use query parameters on the hash
+(e.g., `#/packets?observer=ABC&timeRange=24h`) for filter state.
+Existing patterns: `#/nodes/{pubkey}?section=node-neighbors`, `#/analytics?tab=collisions`, `#/packets/{hash}`.
+
 ## What NOT to Do
 - **Don't check in private information** — no names, API keys, tokens, passwords, IP addresses, personal data, or any identifying information. This is a PUBLIC repo.
 - Don't add npm dependencies without asking

DEPLOY.md

@@ -0,0 +1,131 @@
+# Deploy CoreScope
+
+Pre-built images are published to GHCR for `linux/amd64` and `linux/arm64` (Raspberry Pi 4/5).
+
+## Quick Start
+
+### Docker run
+
+```bash
+docker run -d --name corescope \
+  -p 80:80 \
+  -v corescope-data:/app/data \
+  -e DISABLE_CADDY=true \
+  ghcr.io/kpa-clawbot/corescope:latest
+```
+
+Open `http://localhost` — done.
+
+### Docker Compose
+
+```bash
+curl -sL https://raw.githubusercontent.com/Kpa-clawbot/CoreScope/master/docker-compose.example.yml \
+  -o docker-compose.yml
+docker compose up -d
+```
+
+## Image Tags
+
+| Tag | Description |
+|-----|-------------|
+| `v3.4.1` | Pinned release (recommended for production) |
+| `v3.4` | Latest patch in v3.4.x |
+| `v3` | Latest minor+patch in v3.x |
+| `latest` | Latest release tag |
+| `edge` | Built from master — unstable, for testing |
+
+## Configuration
+
+Settings can be overridden via environment variables:
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `DISABLE_CADDY` | `false` | Skip internal Caddy (set `true` behind a reverse proxy) |
+| `DISABLE_MOSQUITTO` | `false` | Skip internal MQTT broker (use external) |
+| `HTTP_PORT` | `80` | Host port mapping |
+| `DATA_DIR` | `./data` | Host path for persistent data |
+
+For advanced configuration, mount a `config.json` into `/app/data/config.json`. See `config.example.json` in the repo.
+
+## Updating
+
+```bash
+docker compose pull
+docker compose up -d
+```
+
+## Data
+
+All persistent data lives in `/app/data`:
+- `meshcore.db` — SQLite database (packets, nodes)
+- `config.json` — custom config (optional)
+- `theme.json` — custom theme (optional)
+
+**Backup:** `cp data/meshcore.db ~/backup/`
+
+## TLS
+
+Option A — **External reverse proxy** (recommended): Run with `DISABLE_CADDY=true`, put nginx/traefik/Cloudflare in front.
+
+Option B — **Built-in Caddy**: Mount a custom Caddyfile at `/etc/caddy/Caddyfile` and expose ports 80+443.
+
+---
+
+## Migrating from manage.sh (existing admins)
+
+If you're currently deploying with `manage.sh` (git clone + local build), you have two options going forward:
+
+### Option A: Keep using manage.sh (no changes needed)
+
+`manage.sh update` continues to work exactly as before — it fetches the latest tag, builds locally, and restarts. Nothing breaks.
+
+```bash
+./manage.sh update          # latest release
+./manage.sh update v3.5.0   # specific version
+```
+
+### Option B: Switch to pre-built images (recommended)
+
+Pre-built images skip the build step entirely — faster updates, no Go toolchain needed.
+
+**One-time migration:**
+
+1. Stop the current deployment:
+   ```bash
+   ./manage.sh stop
+   ```
+
+2. Your data is in `~/meshcore-data/` (or whatever `PROD_DATA_DIR` is set to). It's untouched — the database, config, and theme files persist.
+
+3. Copy `docker-compose.example.yml` to where you want to run from:
+   ```bash
+   cp docker-compose.example.yml ~/docker-compose.yml
+   ```
+
+4. Start with the pre-built image:
+   ```bash
+   cd ~ && docker compose up -d
+   ```
+
+5. Verify it picked up your existing data:
+   ```bash
+   curl http://localhost/api/stats
+   ```
+
+**Updates after migration:**
+```bash
+docker compose pull && docker compose up -d
+```
+
+### What about manage.sh features?
+
+| manage.sh command | Pre-built equivalent |
+|---|---|
+| `./manage.sh update` | `docker compose pull && docker compose up -d` |
+| `./manage.sh stop` | `docker compose down` |
+| `./manage.sh start` | `docker compose up -d` |
+| `./manage.sh logs` | `docker compose logs -f` |
+| `./manage.sh status` | `docker compose ps` |
+| `./manage.sh setup` | Copy `docker-compose.example.yml`, edit env vars |
+
+`manage.sh` remains available for advanced use cases (building from source, custom patches, development). Pre-built images are recommended for most production deployments.

Dockerfile

@@ -42,6 +42,8 @@ RUN echo "unknown" > .git-commit
 # Supervisor + Mosquitto + Caddy config
 COPY docker/supervisord-go.conf /etc/supervisor/conf.d/supervisord.conf
 COPY docker/supervisord-go-no-mosquitto.conf /etc/supervisor/conf.d/supervisord-no-mosquitto.conf
+COPY docker/supervisord-go-no-caddy.conf /etc/supervisor/conf.d/supervisord-no-caddy.conf
+COPY docker/supervisord-go-no-mosquitto-no-caddy.conf /etc/supervisor/conf.d/supervisord-no-mosquitto-no-caddy.conf
 COPY docker/mosquitto.conf /etc/mosquitto/mosquitto.conf
 COPY docker/Caddyfile /etc/caddy/Caddyfile
 

Dockerfile.go

@@ -40,6 +40,9 @@ RUN if [ ! -f .git-commit ]; then echo "unknown" > .git-commit; fi
 
 # Supervisor + Mosquitto + Caddy config
 COPY docker/supervisord-go.conf /etc/supervisor/conf.d/supervisord.conf
+COPY docker/supervisord-go-no-mosquitto.conf /etc/supervisor/conf.d/supervisord-no-mosquitto.conf
+COPY docker/supervisord-go-no-caddy.conf /etc/supervisor/conf.d/supervisord-no-caddy.conf
+COPY docker/supervisord-go-no-mosquitto-no-caddy.conf /etc/supervisor/conf.d/supervisord-no-mosquitto-no-caddy.conf
 COPY docker/mosquitto.conf /etc/mosquitto/mosquitto.conf
 COPY docker/Caddyfile /etc/caddy/Caddyfile
 

LICENSE

@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<https://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<https://www.gnu.org/licenses/why-not-lgpl.html>.

README.md

@@ -74,9 +74,23 @@ Full experience on your phone — proper touch controls, iOS safe area support,
 
 ## Quick Start
 
-### Docker (Recommended)
+### Pre-built Image (Recommended)
 
-No Go installation needed — everything builds inside the container.
+No build step required — just run:
+
+```bash
+docker run -d --name corescope \
+  -p 80:80 \
+  -v corescope-data:/app/data \
+  ghcr.io/kpa-clawbot/corescope:latest
+```
+
+Open `http://localhost` — done. No config file needed; CoreScope starts with sensible defaults.
+
+See [DEPLOY.md](DEPLOY.md) for image tags, Docker Compose, and migration from `manage.sh`.
+See [docs/deployment.md](docs/deployment.md) for the full deployment guide — MQTT setup, HTTPS options, backups, monitoring, and troubleshooting.
+
+### Build from Source
 
 ```bash
 git clone https://github.com/Kpa-clawbot/CoreScope.git
@@ -95,8 +109,6 @@ The setup wizard walks you through config, domain, HTTPS, build, and run.
 ./manage.sh help         # All commands
 ```
 
-See [docs/DEPLOYMENT.md](docs/DEPLOYMENT.md) for the full deployment guide — HTTPS options (auto cert, bring your own, Cloudflare Tunnel), MQTT security, backups, and troubleshooting.
-
 ### Configure
 
 Copy `config.example.json` to `config.json` and edit:
@@ -242,6 +254,8 @@ Contributions welcome. Please read [AGENTS.md](AGENTS.md) for coding conventions
 
 **Live instance:** [analyzer.00id.net](https://analyzer.00id.net) — all API endpoints are public, no auth required.
 
+**API Documentation:** CoreScope auto-generates an OpenAPI 3.0 spec. Browse the interactive Swagger UI at [`/api/docs`](https://analyzer.00id.net/api/docs) or fetch the machine-readable spec at [`/api/spec`](https://analyzer.00id.net/api/spec).
+
 ## License
 
 MIT

cmd/ingestor/config.go

@@ -2,7 +2,9 @@ package main
 
 import (
 	"encoding/json"
+	"errors"
 	"fmt"
+	"log"
 	"os"
 	"strings"
 
@@ -36,6 +38,7 @@ type Config struct {
 	ChannelKeys     map[string]string `json:"channelKeys,omitempty"`
 	HashChannels    []string          `json:"hashChannels,omitempty"`
 	Retention       *RetentionConfig  `json:"retention,omitempty"`
+	Metrics         *MetricsConfig    `json:"metrics,omitempty"`
 	GeoFilter       *GeoFilterConfig  `json:"geo_filter,omitempty"`
 }
 
@@ -44,7 +47,29 @@ type GeoFilterConfig = geofilter.Config
 
 // RetentionConfig controls how long stale nodes are kept before being moved to inactive_nodes.
 type RetentionConfig struct {
-	NodeDays int `json:"nodeDays"`
+	NodeDays    int `json:"nodeDays"`
+	MetricsDays int `json:"metricsDays"`
+}
+
+// MetricsConfig controls observer metrics collection.
+type MetricsConfig struct {
+	SampleIntervalSec int `json:"sampleIntervalSec"`
+}
+
+// MetricsSampleInterval returns the configured sample interval or 300s default.
+func (c *Config) MetricsSampleInterval() int {
+	if c.Metrics != nil && c.Metrics.SampleIntervalSec > 0 {
+		return c.Metrics.SampleIntervalSec
+	}
+	return 300
+}
+
+// MetricsRetentionDays returns configured metrics retention or 30 days default.
+func (c *Config) MetricsRetentionDays() int {
+	if c.Retention != nil && c.Retention.MetricsDays > 0 {
+		return c.Retention.MetricsDays
+	}
+	return 30
 }
 
 // NodeDaysOrDefault returns the configured retention.nodeDays or 7 if not set.
@@ -56,15 +81,21 @@ func (c *Config) NodeDaysOrDefault() int {
 }
 
 // LoadConfig reads configuration from a JSON file, with env var overrides.
+// If the config file does not exist, sensible defaults are used (zero-config startup).
 func LoadConfig(path string) (*Config, error) {
+	var cfg Config
+
 	data, err := os.ReadFile(path)
 	if err != nil {
-		return nil, fmt.Errorf("reading config %s: %w", path, err)
-	}
-
-	var cfg Config
-	if err := json.Unmarshal(data, &cfg); err != nil {
-		return nil, fmt.Errorf("parsing config %s: %w", path, err)
+		if !errors.Is(err, os.ErrNotExist) {
+			return nil, fmt.Errorf("reading config %s: %w", path, err)
+		}
+		// Config file doesn't exist — use defaults (zero-config mode)
+		log.Printf("config file %s not found, using sensible defaults", path)
+	} else {
+		if err := json.Unmarshal(data, &cfg); err != nil {
+			return nil, fmt.Errorf("parsing config %s: %w", path, err)
+		}
 	}
 
 	// Env var overrides
@@ -98,6 +129,16 @@ func LoadConfig(path string) (*Config, error) {
 		}}
 	}
 
+	// Default MQTT source: connect to localhost broker when no sources configured
+	if len(cfg.MQTTSources) == 0 {
+		cfg.MQTTSources = []MQTTSource{{
+			Name:   "local",
+			Broker: "mqtt://localhost:1883",
+			Topics: []string{"meshcore/#"},
+		}}
+		log.Printf("no MQTT sources configured, defaulting to mqtt://localhost:1883")
+	}
+
 	return &cfg, nil
 }
 

cmd/ingestor/config_test.go

@@ -32,9 +32,25 @@ func TestLoadConfigValidJSON(t *testing.T) {
 }
 
 func TestLoadConfigMissingFile(t *testing.T) {
-	_, err := LoadConfig("/nonexistent/path/config.json")
-	if err == nil {
-		t.Error("expected error for missing file")
+	t.Setenv("DB_PATH", "")
+	t.Setenv("MQTT_BROKER", "")
+
+	cfg, err := LoadConfig("/nonexistent/path/config.json")
+	if err != nil {
+		t.Fatalf("missing config should not error (zero-config mode), got: %v", err)
+	}
+	if cfg.DBPath != "data/meshcore.db" {
+		t.Errorf("dbPath=%s, want data/meshcore.db", cfg.DBPath)
+	}
+	// Should default to localhost MQTT
+	if len(cfg.MQTTSources) != 1 {
+		t.Fatalf("mqttSources len=%d, want 1", len(cfg.MQTTSources))
+	}
+	if cfg.MQTTSources[0].Broker != "mqtt://localhost:1883" {
+		t.Errorf("default broker=%s, want mqtt://localhost:1883", cfg.MQTTSources[0].Broker)
+	}
+	if cfg.MQTTSources[0].Name != "local" {
+		t.Errorf("default source name=%s, want local", cfg.MQTTSources[0].Name)
 	}
 }
 
@@ -196,8 +212,8 @@ func TestLoadConfigLegacyMQTTEmptyBroker(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	if len(cfg.MQTTSources) != 0 {
-		t.Errorf("mqttSources should be empty when legacy broker is empty, got %d", len(cfg.MQTTSources))
+	if len(cfg.MQTTSources) != 1 || cfg.MQTTSources[0].Name != "local" {
+		t.Errorf("mqttSources should default to local broker when legacy broker is empty, got %v", cfg.MQTTSources)
 	}
 }
 

cmd/ingestor/db.go

@@ -39,11 +39,19 @@ type Store struct {
 	stmtGetObserverRowid       *sql.Stmt
 	stmtUpdateObserverLastSeen *sql.Stmt
 	stmtUpdateNodeTelemetry    *sql.Stmt
+	stmtUpsertMetrics          *sql.Stmt
+
+	sampleIntervalSec int
 }
 
 // OpenStore opens or creates a SQLite DB at the given path, applying the
 // v3 schema that is compatible with the Node.js server.
 func OpenStore(dbPath string) (*Store, error) {
+	return OpenStoreWithInterval(dbPath, 300)
+}
+
+// OpenStoreWithInterval opens or creates a SQLite DB with a configurable sample interval.
+func OpenStoreWithInterval(dbPath string, sampleIntervalSec int) (*Store, error) {
 	dir := filepath.Dir(dbPath)
 	if err := os.MkdirAll(dir, 0o755); err != nil {
 		return nil, fmt.Errorf("creating data dir: %w", err)
@@ -66,7 +74,7 @@ func OpenStore(dbPath string) (*Store, error) {
 		return nil, fmt.Errorf("applying schema: %w", err)
 	}
 
-	s := &Store{db: db}
+	s := &Store{db: db, sampleIntervalSec: sampleIntervalSec}
 	if err := s.prepareStatements(); err != nil {
 		return nil, fmt.Errorf("preparing statements: %w", err)
 	}
@@ -292,6 +300,51 @@ func applySchema(db *sql.DB) error {
 		log.Println("[migration] observations timestamp index created")
 	}
 
+	// observer_metrics table for RF health dashboard
+	row = db.QueryRow("SELECT 1 FROM _migrations WHERE name = 'observer_metrics_v1'")
+	if row.Scan(&migDone) != nil {
+		log.Println("[migration] Creating observer_metrics table...")
+		_, err := db.Exec(`
+			CREATE TABLE IF NOT EXISTS observer_metrics (
+				observer_id TEXT NOT NULL,
+				timestamp TEXT NOT NULL,
+				noise_floor REAL,
+				tx_air_secs INTEGER,
+				rx_air_secs INTEGER,
+				recv_errors INTEGER,
+				battery_mv INTEGER,
+				PRIMARY KEY (observer_id, timestamp)
+			)
+		`)
+		if err != nil {
+			return fmt.Errorf("observer_metrics schema: %w", err)
+		}
+		db.Exec(`INSERT INTO _migrations (name) VALUES ('observer_metrics_v1')`)
+		log.Println("[migration] observer_metrics table created")
+	}
+
+	// Migration: add timestamp index for cross-observer time-range queries
+	row = db.QueryRow("SELECT 1 FROM _migrations WHERE name = 'observer_metrics_ts_idx'")
+	if row.Scan(&migDone) != nil {
+		log.Println("[migration] Creating observer_metrics timestamp index...")
+		_, err := db.Exec(`CREATE INDEX IF NOT EXISTS idx_observer_metrics_timestamp ON observer_metrics(timestamp)`)
+		if err != nil {
+			return fmt.Errorf("observer_metrics timestamp index: %w", err)
+		}
+		db.Exec(`INSERT INTO _migrations (name) VALUES ('observer_metrics_ts_idx')`)
+		log.Println("[migration] observer_metrics timestamp index created")
+	}
+
+	// Migration: add packets_sent and packets_recv columns to observer_metrics
+	row = db.QueryRow("SELECT 1 FROM _migrations WHERE name = 'observer_metrics_packets_v1'")
+	if row.Scan(&migDone) != nil {
+		log.Println("[migration] Adding packets_sent/packets_recv columns to observer_metrics...")
+		db.Exec(`ALTER TABLE observer_metrics ADD COLUMN packets_sent INTEGER`)
+		db.Exec(`ALTER TABLE observer_metrics ADD COLUMN packets_recv INTEGER`)
+		db.Exec(`INSERT INTO _migrations (name) VALUES ('observer_metrics_packets_v1')`)
+		log.Println("[migration] packets_sent/packets_recv columns added")
+	}
+
 	return nil
 }
 
@@ -385,6 +438,14 @@ func (s *Store) prepareStatements() error {
 		return err
 	}
 
+	s.stmtUpsertMetrics, err = s.db.Prepare(`
+		INSERT OR REPLACE INTO observer_metrics (observer_id, timestamp, noise_floor, tx_air_secs, rx_air_secs, recv_errors, battery_mv, packets_sent, packets_recv)
+		VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+	`)
+	if err != nil {
+		return err
+	}
+
 	return nil
 }
 
@@ -517,6 +578,11 @@ type ObserverMeta struct {
 	BatteryMv     *int     // millivolts, always integer
 	UptimeSecs    *int64   // seconds, always integer
 	NoiseFloor    *float64 // dBm, may have decimals
+	TxAirSecs     *int     // cumulative TX seconds since boot
+	RxAirSecs     *int     // cumulative RX seconds since boot
+	RecvErrors    *int     // cumulative CRC/decode failures since boot
+	PacketsSent   *int     // cumulative packets sent since boot
+	PacketsRecv   *int     // cumulative packets received since boot
 }
 
 // UpsertObserver inserts or updates an observer with optional hardware metadata.
@@ -568,6 +634,79 @@ func (s *Store) Close() error {
 	return s.db.Close()
 }
 
+// RoundToInterval rounds a time to the nearest sample interval boundary.
+func RoundToInterval(t time.Time, intervalSec int) time.Time {
+	if intervalSec <= 0 {
+		intervalSec = 300
+	}
+	epoch := t.Unix()
+	half := int64(intervalSec) / 2
+	rounded := ((epoch + half) / int64(intervalSec)) * int64(intervalSec)
+	return time.Unix(rounded, 0).UTC()
+}
+
+// MetricsData holds the fields to insert into observer_metrics.
+type MetricsData struct {
+	ObserverID  string
+	NoiseFloor  *float64
+	TxAirSecs   *int
+	RxAirSecs   *int
+	RecvErrors  *int
+	BatteryMv   *int
+	PacketsSent *int
+	PacketsRecv *int
+}
+
+// InsertMetrics inserts a metrics sample for an observer using ingestor wall clock.
+func (s *Store) InsertMetrics(data *MetricsData) error {
+	ts := RoundToInterval(time.Now().UTC(), s.sampleIntervalSec)
+	tsStr := ts.Format(time.RFC3339)
+
+	var nf, txAir, rxAir, recvErr, batt, pktSent, pktRecv interface{}
+	if data.NoiseFloor != nil {
+		nf = *data.NoiseFloor
+	}
+	if data.TxAirSecs != nil {
+		txAir = *data.TxAirSecs
+	}
+	if data.RxAirSecs != nil {
+		rxAir = *data.RxAirSecs
+	}
+	if data.RecvErrors != nil {
+		recvErr = *data.RecvErrors
+	}
+	if data.BatteryMv != nil {
+		batt = *data.BatteryMv
+	}
+	if data.PacketsSent != nil {
+		pktSent = *data.PacketsSent
+	}
+	if data.PacketsRecv != nil {
+		pktRecv = *data.PacketsRecv
+	}
+
+	_, err := s.stmtUpsertMetrics.Exec(data.ObserverID, tsStr, nf, txAir, rxAir, recvErr, batt, pktSent, pktRecv)
+	if err != nil {
+		s.Stats.WriteErrors.Add(1)
+		return fmt.Errorf("insert metrics: %w", err)
+	}
+	return nil
+}
+
+// PruneOldMetrics deletes observer_metrics rows older than retentionDays.
+func (s *Store) PruneOldMetrics(retentionDays int) (int64, error) {
+	cutoff := time.Now().UTC().AddDate(0, 0, -retentionDays).Format(time.RFC3339)
+	result, err := s.db.Exec(`DELETE FROM observer_metrics WHERE timestamp < ?`, cutoff)
+	if err != nil {
+		return 0, fmt.Errorf("prune metrics: %w", err)
+	}
+	n, _ := result.RowsAffected()
+	if n > 0 {
+		log.Printf("[metrics] Pruned %d rows older than %d days", n, retentionDays)
+	}
+	return n, nil
+}
+
 // Checkpoint forces a WAL checkpoint to release the WAL lock file,
 // preventing lock contention with a new process starting up.
 func (s *Store) Checkpoint() {

cmd/ingestor/db_test.go

@@ -576,7 +576,7 @@ func TestEndToEndIngest(t *testing.T) {
 	// Simulate full pipeline: decode + insert
 	rawHex := "120046D62DE27D4C5194D7821FC5A34A45565DCC2537B300B9AB6275255CEFB65D840CE5C169C94C9AED39E8BCB6CB6EB0335497A198B33A1A610CD3B03D8DCFC160900E5244280323EE0B44CACAB8F02B5B38B91CFA18BD067B0B5E63E94CFC85F758A8530B9240933402E0E6B8F84D5252322D52"
 
-	decoded, err := DecodePacket(rawHex, nil)
+	decoded, err := DecodePacket(rawHex, nil, false)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -764,7 +764,7 @@ func TestInsertTransmissionNilSNRRSSI(t *testing.T) {
 
 func TestBuildPacketData(t *testing.T) {
 	rawHex := "0A00D69FD7A5A7475DB07337749AE61FA53A4788E976"
-	decoded, err := DecodePacket(rawHex, nil)
+	decoded, err := DecodePacket(rawHex, nil, false)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -818,7 +818,7 @@ func TestBuildPacketData(t *testing.T) {
 func TestBuildPacketDataWithHops(t *testing.T) {
 	// A packet with actual hops in the path
 	raw := "0505AABBCCDDEE" + strings.Repeat("00", 10)
-	decoded, err := DecodePacket(raw, nil)
+	decoded, err := DecodePacket(raw, nil, false)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -834,7 +834,7 @@ func TestBuildPacketDataWithHops(t *testing.T) {
 }
 
 func TestBuildPacketDataNilSNRRSSI(t *testing.T) {
-	decoded, _ := DecodePacket("0A00"+strings.Repeat("00", 10), nil)
+	decoded, _ := DecodePacket("0A00"+strings.Repeat("00", 10), nil, false)
 	msg := &MQTTPacketMessage{Raw: "0A00" + strings.Repeat("00", 10)}
 	pkt := BuildPacketData(msg, decoded, "", "")
 
@@ -1624,7 +1624,7 @@ func TestObsTimestampIndexMigration(t *testing.T) {
 
 func TestBuildPacketDataScoreAndDirection(t *testing.T) {
 	rawHex := "0A00D69FD7A5A7475DB07337749AE61FA53A4788E976"
-	decoded, err := DecodePacket(rawHex, nil)
+	decoded, err := DecodePacket(rawHex, nil, false)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -1647,7 +1647,7 @@ func TestBuildPacketDataScoreAndDirection(t *testing.T) {
 }
 
 func TestBuildPacketDataNilScoreDirection(t *testing.T) {
-	decoded, _ := DecodePacket("0A00"+strings.Repeat("00", 10), nil)
+	decoded, _ := DecodePacket("0A00"+strings.Repeat("00", 10), nil, false)
 	msg := &MQTTPacketMessage{Raw: "0A00" + strings.Repeat("00", 10)}
 	pkt := BuildPacketData(msg, decoded, "", "")
 
@@ -1703,3 +1703,182 @@ func TestInsertTransmissionWithScoreAndDirection(t *testing.T) {
 }
 
 func ptrFloat(f float64) *float64 { return &f }
+func ptrInt(i int) *int           { return &i }
+
+func TestRoundToInterval(t *testing.T) {
+	tests := []struct {
+		input    time.Time
+		interval int
+		want     time.Time
+	}{
+		{time.Date(2026, 4, 5, 10, 2, 0, 0, time.UTC), 300, time.Date(2026, 4, 5, 10, 0, 0, 0, time.UTC)},
+		{time.Date(2026, 4, 5, 10, 3, 0, 0, time.UTC), 300, time.Date(2026, 4, 5, 10, 5, 0, 0, time.UTC)},
+		{time.Date(2026, 4, 5, 10, 2, 30, 0, time.UTC), 300, time.Date(2026, 4, 5, 10, 5, 0, 0, time.UTC)},
+		{time.Date(2026, 4, 5, 10, 5, 0, 0, time.UTC), 300, time.Date(2026, 4, 5, 10, 5, 0, 0, time.UTC)},
+		{time.Date(2026, 4, 5, 10, 7, 29, 0, time.UTC), 300, time.Date(2026, 4, 5, 10, 5, 0, 0, time.UTC)},
+	}
+	for _, tc := range tests {
+		got := RoundToInterval(tc.input, tc.interval)
+		if !got.Equal(tc.want) {
+			t.Errorf("RoundToInterval(%v, %d) = %v, want %v", tc.input, tc.interval, got, tc.want)
+		}
+	}
+}
+
+func TestInsertMetrics(t *testing.T) {
+	store, err := OpenStore(tempDBPath(t))
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer store.Close()
+
+	nf := -112.5
+	txAir := 100
+	rxAir := 500
+	recvErr := 3
+	batt := 3720
+	data := &MetricsData{
+		ObserverID: "obs1",
+		NoiseFloor: &nf,
+		TxAirSecs:  &txAir,
+		RxAirSecs:  &rxAir,
+		RecvErrors: &recvErr,
+		BatteryMv:  &batt,
+	}
+
+	if err := store.InsertMetrics(data); err != nil {
+		t.Fatalf("InsertMetrics: %v", err)
+	}
+
+	// Verify insertion
+	var count int
+	store.db.QueryRow("SELECT COUNT(*) FROM observer_metrics WHERE observer_id = 'obs1'").Scan(&count)
+	if count != 1 {
+		t.Errorf("expected 1 row, got %d", count)
+	}
+
+	// Verify values
+	var gotNF float64
+	var gotTx, gotRx, gotErr, gotBatt int
+	store.db.QueryRow("SELECT noise_floor, tx_air_secs, rx_air_secs, recv_errors, battery_mv FROM observer_metrics WHERE observer_id = 'obs1'").Scan(&gotNF, &gotTx, &gotRx, &gotErr, &gotBatt)
+	if gotNF != -112.5 {
+		t.Errorf("noise_floor = %v, want -112.5", gotNF)
+	}
+	if gotTx != 100 {
+		t.Errorf("tx_air_secs = %d, want 100", gotTx)
+	}
+}
+
+func TestInsertMetricsIdempotent(t *testing.T) {
+	store, err := OpenStoreWithInterval(tempDBPath(t), 300)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer store.Close()
+
+	nf := -110.0
+	data := &MetricsData{ObserverID: "obs1", NoiseFloor: &nf}
+
+	// Insert twice — should result in 1 row (INSERT OR REPLACE)
+	store.InsertMetrics(data)
+	nf2 := -108.0
+	data.NoiseFloor = &nf2
+	store.InsertMetrics(data)
+
+	var count int
+	store.db.QueryRow("SELECT COUNT(*) FROM observer_metrics WHERE observer_id = 'obs1'").Scan(&count)
+	if count != 1 {
+		t.Errorf("expected 1 row (idempotent), got %d", count)
+	}
+
+	// Verify the value was replaced
+	var gotNF float64
+	store.db.QueryRow("SELECT noise_floor FROM observer_metrics WHERE observer_id = 'obs1'").Scan(&gotNF)
+	if gotNF != -108.0 {
+		t.Errorf("noise_floor = %v, want -108.0 (replaced)", gotNF)
+	}
+}
+
+func TestInsertMetricsNullFields(t *testing.T) {
+	store, err := OpenStore(tempDBPath(t))
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer store.Close()
+
+	nf := -115.0
+	data := &MetricsData{
+		ObserverID: "obs1",
+		NoiseFloor: &nf,
+		// All other fields nil
+	}
+
+	if err := store.InsertMetrics(data); err != nil {
+		t.Fatalf("InsertMetrics with nulls: %v", err)
+	}
+
+	var gotNF sql.NullFloat64
+	var gotTx sql.NullInt64
+	store.db.QueryRow("SELECT noise_floor, tx_air_secs FROM observer_metrics WHERE observer_id = 'obs1'").Scan(&gotNF, &gotTx)
+	if !gotNF.Valid || gotNF.Float64 != -115.0 {
+		t.Errorf("noise_floor = %v, want -115.0", gotNF)
+	}
+	if gotTx.Valid {
+		t.Errorf("tx_air_secs should be NULL, got %v", gotTx.Int64)
+	}
+}
+
+func TestPruneOldMetrics(t *testing.T) {
+	store, err := OpenStore(tempDBPath(t))
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer store.Close()
+
+	// Insert old and new metrics directly
+	oldTs := time.Now().UTC().AddDate(0, 0, -40).Format(time.RFC3339)
+	newTs := time.Now().UTC().Format(time.RFC3339)
+	store.db.Exec("INSERT INTO observer_metrics (observer_id, timestamp, noise_floor) VALUES (?, ?, ?)", "obs1", oldTs, -110.0)
+	store.db.Exec("INSERT INTO observer_metrics (observer_id, timestamp, noise_floor) VALUES (?, ?, ?)", "obs1", newTs, -112.0)
+
+	n, err := store.PruneOldMetrics(30)
+	if err != nil {
+		t.Fatalf("PruneOldMetrics: %v", err)
+	}
+	if n != 1 {
+		t.Errorf("pruned %d rows, want 1", n)
+	}
+
+	var count int
+	store.db.QueryRow("SELECT COUNT(*) FROM observer_metrics").Scan(&count)
+	if count != 1 {
+		t.Errorf("expected 1 row remaining, got %d", count)
+	}
+}
+
+func TestExtractObserverMetaNewFields(t *testing.T) {
+	msg := map[string]interface{}{
+		"model": "L1",
+		"stats": map[string]interface{}{
+			"noise_floor":  -112.5,
+			"battery_mv":   3720.0,
+			"uptime_secs":  86400.0,
+			"tx_air_secs":  100.0,
+			"rx_air_secs":  500.0,
+			"recv_errors":  3.0,
+		},
+	}
+	meta := extractObserverMeta(msg)
+	if meta == nil {
+		t.Fatal("expected non-nil meta")
+	}
+	if meta.TxAirSecs == nil || *meta.TxAirSecs != 100 {
+		t.Errorf("TxAirSecs = %v, want 100", meta.TxAirSecs)
+	}
+	if meta.RxAirSecs == nil || *meta.RxAirSecs != 500 {
+		t.Errorf("RxAirSecs = %v, want 500", meta.RxAirSecs)
+	}
+	if meta.RecvErrors == nil || *meta.RecvErrors != 3 {
+		t.Errorf("RecvErrors = %v, want 3", meta.RecvErrors)
+	}
+}

cmd/ingestor/decoder.go

@@ -11,6 +11,8 @@ import (
 	"math"
 	"strings"
 	"unicode/utf8"
+
+	"github.com/meshcore-analyzer/sigvalidate"
 )
 
 // Route type constants (header bits 1-0)
@@ -109,6 +111,7 @@ type Payload struct {
 	Timestamp     uint32       `json:"timestamp,omitempty"`
 	TimestampISO  string       `json:"timestampISO,omitempty"`
 	Signature     string       `json:"signature,omitempty"`
+	SignatureValid *bool       `json:"signatureValid,omitempty"`
 	Flags         *AdvertFlags `json:"flags,omitempty"`
 	Lat           *float64     `json:"lat,omitempty"`
 	Lon           *float64     `json:"lon,omitempty"`
@@ -215,7 +218,7 @@ func decodeAck(buf []byte) Payload {
 	}
 }
 
-func decodeAdvert(buf []byte) Payload {
+func decodeAdvert(buf []byte, validateSignatures bool) Payload {
 	if len(buf) < 100 {
 		return Payload{Type: "ADVERT", Error: "too short for advert", RawHex: hex.EncodeToString(buf)}
 	}
@@ -233,6 +236,11 @@ func decodeAdvert(buf []byte) Payload {
 		Signature:    signature,
 	}
 
+	if validateSignatures {
+		valid := sigvalidate.ValidateAdvertSignature(buf[0:32], buf[36:100], timestamp, appdata)
+		p.SignatureValid = &valid
+	}
+
 	if len(appdata) > 0 {
 		flags := appdata[0]
 		advType := int(flags & 0x0F)
@@ -506,7 +514,7 @@ func decodeTrace(buf []byte) Payload {
 	return p
 }
 
-func decodePayload(payloadType int, buf []byte, channelKeys map[string]string) Payload {
+func decodePayload(payloadType int, buf []byte, channelKeys map[string]string, validateSignatures bool) Payload {
 	switch payloadType {
 	case PayloadREQ:
 		return decodeEncryptedPayload("REQ", buf)
@@ -517,7 +525,7 @@ func decodePayload(payloadType int, buf []byte, channelKeys map[string]string) P
 	case PayloadACK:
 		return decodeAck(buf)
 	case PayloadADVERT:
-		return decodeAdvert(buf)
+		return decodeAdvert(buf, validateSignatures)
 	case PayloadGRP_TXT:
 		return decodeGrpTxt(buf, channelKeys)
 	case PayloadANON_REQ:
@@ -532,7 +540,7 @@ func decodePayload(payloadType int, buf []byte, channelKeys map[string]string) P
 }
 
 // DecodePacket decodes a hex-encoded MeshCore packet.
-func DecodePacket(hexString string, channelKeys map[string]string) (*DecodedPacket, error) {
+func DecodePacket(hexString string, channelKeys map[string]string, validateSignatures bool) (*DecodedPacket, error) {
 	hexString = strings.ReplaceAll(hexString, " ", "")
 	hexString = strings.ReplaceAll(hexString, "\n", "")
 	hexString = strings.ReplaceAll(hexString, "\r", "")
@@ -570,7 +578,7 @@ func DecodePacket(hexString string, channelKeys map[string]string) (*DecodedPack
 	offset += bytesConsumed
 
 	payloadBuf := buf[offset:]
-	payload := decodePayload(header.PayloadType, payloadBuf, channelKeys)
+	payload := decodePayload(header.PayloadType, payloadBuf, channelKeys, validateSignatures)
 
 	// TRACE packets store hop IDs in the payload (buf[9:]) rather than the header
 	// path field. The header path byte still encodes hashSize in bits 6-7, which
@@ -587,6 +595,16 @@ func DecodePacket(hexString string, channelKeys map[string]string) (*DecodedPack
 		}
 	}
 
+	// Zero-hop direct packets have hash_count=0 (lower 6 bits of pathByte),
+	// which makes the generic formula yield a bogus hashSize. Reset to 0
+	// (unknown) so API consumers get correct data. We mask with 0x3F to check
+	// only hash_count, matching the JS frontend approach — the upper hash_size
+	// bits are meaningless when there are no hops. Skip TRACE packets — they
+	// use hashSize to parse hops from the payload above.
+	if (header.RouteType == RouteDirect || header.RouteType == RouteTransportDirect) && pathByte&0x3F == 0 && header.PayloadType != PayloadTRACE {
+		path.HashSize = 0
+	}
+
 	return &DecodedPacket{
 		Header:         header,
 		TransportCodes: tc,

cmd/ingestor/decoder_test.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"crypto/aes"
+	"crypto/ed25519"
 	"crypto/hmac"
 	"crypto/sha256"
 	"encoding/binary"
@@ -9,6 +10,8 @@ import (
 	"math"
 	"strings"
 	"testing"
+
+	"github.com/meshcore-analyzer/sigvalidate"
 )
 
 func TestDecodeHeaderRoutTypes(t *testing.T) {
@@ -55,7 +58,7 @@ func TestDecodeHeaderPayloadTypes(t *testing.T) {
 
 func TestDecodePathZeroHops(t *testing.T) {
 	// 0x00: 0 hops, 1-byte hashes
-	pkt, err := DecodePacket("0500"+strings.Repeat("00", 10), nil)
+	pkt, err := DecodePacket("0500"+strings.Repeat("00", 10), nil, false)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -72,7 +75,7 @@ func TestDecodePathZeroHops(t *testing.T) {
 
 func TestDecodePath1ByteHashes(t *testing.T) {
 	// 0x05: 5 hops, 1-byte hashes → 5 path bytes
-	pkt, err := DecodePacket("0505"+"AABBCCDDEE"+strings.Repeat("00", 10), nil)
+	pkt, err := DecodePacket("0505"+"AABBCCDDEE"+strings.Repeat("00", 10), nil, false)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -95,7 +98,7 @@ func TestDecodePath1ByteHashes(t *testing.T) {
 
 func TestDecodePath2ByteHashes(t *testing.T) {
 	// 0x45: 5 hops, 2-byte hashes
-	pkt, err := DecodePacket("0545"+"AA11BB22CC33DD44EE55"+strings.Repeat("00", 10), nil)
+	pkt, err := DecodePacket("0545"+"AA11BB22CC33DD44EE55"+strings.Repeat("00", 10), nil, false)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -112,7 +115,7 @@ func TestDecodePath2ByteHashes(t *testing.T) {
 
 func TestDecodePath3ByteHashes(t *testing.T) {
 	// 0x8A: 10 hops, 3-byte hashes
-	pkt, err := DecodePacket("058A"+strings.Repeat("AA11FF", 10)+strings.Repeat("00", 10), nil)
+	pkt, err := DecodePacket("058A"+strings.Repeat("AA11FF", 10)+strings.Repeat("00", 10), nil, false)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -131,7 +134,7 @@ func TestTransportCodes(t *testing.T) {
 	// Route type 0 (TRANSPORT_FLOOD) should have transport codes
 	// Firmware order: header + transport_codes(4) + path_len + path + payload
 	hex := "14" + "AABB" + "CCDD" + "00" + strings.Repeat("00", 10)
-	pkt, err := DecodePacket(hex, nil)
+	pkt, err := DecodePacket(hex, nil, false)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -149,7 +152,7 @@ func TestTransportCodes(t *testing.T) {
 	}
 
 	// Route type 1 (FLOOD) should NOT have transport codes
-	pkt2, err := DecodePacket("0500"+strings.Repeat("00", 10), nil)
+	pkt2, err := DecodePacket("0500"+strings.Repeat("00", 10), nil, false)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -169,7 +172,7 @@ func TestDecodeAdvertFull(t *testing.T) {
 	name := "546573744E6F6465" // "TestNode"
 
 	hex := "1200" + pubkey + timestamp + signature + flags + lat + lon + name
-	pkt, err := DecodePacket(hex, nil)
+	pkt, err := DecodePacket(hex, nil, false)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -227,7 +230,7 @@ func TestDecodeAdvertTypeEnums(t *testing.T) {
 	makeAdvert := func(flagsByte byte) *DecodedPacket {
 		hex := "1200" + strings.Repeat("AA", 32) + "00000000" + strings.Repeat("BB", 64) +
 			strings.ToUpper(string([]byte{hexDigit(flagsByte>>4), hexDigit(flagsByte & 0x0f)}))
-		pkt, err := DecodePacket(hex, nil)
+		pkt, err := DecodePacket(hex, nil, false)
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -272,7 +275,7 @@ func hexDigit(v byte) byte {
 
 func TestDecodeAdvertNoLocationNoName(t *testing.T) {
 	hex := "1200" + strings.Repeat("CC", 32) + "00000000" + strings.Repeat("DD", 64) + "02"
-	pkt, err := DecodePacket(hex, nil)
+	pkt, err := DecodePacket(hex, nil, false)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -291,7 +294,7 @@ func TestDecodeAdvertNoLocationNoName(t *testing.T) {
 }
 
 func TestGoldenFixtureTxtMsg(t *testing.T) {
-	pkt, err := DecodePacket("0A00D69FD7A5A7475DB07337749AE61FA53A4788E976", nil)
+	pkt, err := DecodePacket("0A00D69FD7A5A7475DB07337749AE61FA53A4788E976", nil, false)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -314,7 +317,7 @@ func TestGoldenFixtureTxtMsg(t *testing.T) {
 
 func TestGoldenFixtureAdvert(t *testing.T) {
 	rawHex := "120046D62DE27D4C5194D7821FC5A34A45565DCC2537B300B9AB6275255CEFB65D840CE5C169C94C9AED39E8BCB6CB6EB0335497A198B33A1A610CD3B03D8DCFC160900E5244280323EE0B44CACAB8F02B5B38B91CFA18BD067B0B5E63E94CFC85F758A8530B9240933402E0E6B8F84D5252322D52"
-	pkt, err := DecodePacket(rawHex, nil)
+	pkt, err := DecodePacket(rawHex, nil, false)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -337,7 +340,7 @@ func TestGoldenFixtureAdvert(t *testing.T) {
 
 func TestGoldenFixtureUnicodeAdvert(t *testing.T) {
 	rawHex := "120073CFF971E1CB5754A742C152B2D2E0EB108A19B246D663ED8898A72C4A5AD86EA6768E66694B025EDF6939D5C44CFF719C5D5520E5F06B20680A83AD9C2C61C3227BBB977A85EE462F3553445FECF8EDD05C234ECE217272E503F14D6DF2B1B9B133890C923CDF3002F8FDC1F85045414BF09F8CB3"
-	pkt, err := DecodePacket(rawHex, nil)
+	pkt, err := DecodePacket(rawHex, nil, false)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -354,14 +357,14 @@ func TestGoldenFixtureUnicodeAdvert(t *testing.T) {
 }
 
 func TestDecodePacketTooShort(t *testing.T) {
-	_, err := DecodePacket("FF", nil)
+	_, err := DecodePacket("FF", nil, false)
 	if err == nil {
 		t.Error("expected error for 1-byte packet")
 	}
 }
 
 func TestDecodePacketInvalidHex(t *testing.T) {
-	_, err := DecodePacket("ZZZZ", nil)
+	_, err := DecodePacket("ZZZZ", nil, false)
 	if err == nil {
 		t.Error("expected error for invalid hex")
 	}
@@ -568,7 +571,7 @@ func TestDecodeTracePathParsing(t *testing.T) {
 	// Packet from issue #276: 260001807dca00000000007d547d
 	// Path byte 0x00 → hashSize=1, hops in payload at buf[9:] = 7d 54 7d
 	// Expected path: ["7D", "54", "7D"]
-	pkt, err := DecodePacket("260001807dca00000000007d547d", nil)
+	pkt, err := DecodePacket("260001807dca00000000007d547d", nil, false)
 	if err != nil {
 		t.Fatalf("DecodePacket error: %v", err)
 	}
@@ -590,7 +593,7 @@ func TestDecodeTracePathParsing(t *testing.T) {
 }
 
 func TestDecodeAdvertShort(t *testing.T) {
-	p := decodeAdvert(make([]byte, 50))
+	p := decodeAdvert(make([]byte, 50), false)
 	if p.Error != "too short for advert" {
 		t.Errorf("expected 'too short for advert' error, got %q", p.Error)
 	}
@@ -628,7 +631,7 @@ func TestDecodeEncryptedPayloadValid(t *testing.T) {
 
 func TestDecodePayloadGRPData(t *testing.T) {
 	buf := []byte{0x01, 0x02, 0x03}
-	p := decodePayload(PayloadGRP_DATA, buf, nil)
+	p := decodePayload(PayloadGRP_DATA, buf, nil, false)
 	if p.Type != "UNKNOWN" {
 		t.Errorf("type=%s, want UNKNOWN", p.Type)
 	}
@@ -639,7 +642,7 @@ func TestDecodePayloadGRPData(t *testing.T) {
 
 func TestDecodePayloadRAWCustom(t *testing.T) {
 	buf := []byte{0xFF, 0xFE}
-	p := decodePayload(PayloadRAW_CUSTOM, buf, nil)
+	p := decodePayload(PayloadRAW_CUSTOM, buf, nil, false)
 	if p.Type != "UNKNOWN" {
 		t.Errorf("type=%s, want UNKNOWN", p.Type)
 	}
@@ -647,49 +650,49 @@ func TestDecodePayloadRAWCustom(t *testing.T) {
 
 func TestDecodePayloadAllTypes(t *testing.T) {
 	// REQ
-	p := decodePayload(PayloadREQ, make([]byte, 10), nil)
+	p := decodePayload(PayloadREQ, make([]byte, 10), nil, false)
 	if p.Type != "REQ" {
 		t.Errorf("REQ: type=%s", p.Type)
 	}
 
 	// RESPONSE
-	p = decodePayload(PayloadRESPONSE, make([]byte, 10), nil)
+	p = decodePayload(PayloadRESPONSE, make([]byte, 10), nil, false)
 	if p.Type != "RESPONSE" {
 		t.Errorf("RESPONSE: type=%s", p.Type)
 	}
 
 	// TXT_MSG
-	p = decodePayload(PayloadTXT_MSG, make([]byte, 10), nil)
+	p = decodePayload(PayloadTXT_MSG, make([]byte, 10), nil, false)
 	if p.Type != "TXT_MSG" {
 		t.Errorf("TXT_MSG: type=%s", p.Type)
 	}
 
 	// ACK
-	p = decodePayload(PayloadACK, make([]byte, 10), nil)
+	p = decodePayload(PayloadACK, make([]byte, 10), nil, false)
 	if p.Type != "ACK" {
 		t.Errorf("ACK: type=%s", p.Type)
 	}
 
 	// GRP_TXT
-	p = decodePayload(PayloadGRP_TXT, make([]byte, 10), nil)
+	p = decodePayload(PayloadGRP_TXT, make([]byte, 10), nil, false)
 	if p.Type != "GRP_TXT" {
 		t.Errorf("GRP_TXT: type=%s", p.Type)
 	}
 
 	// ANON_REQ
-	p = decodePayload(PayloadANON_REQ, make([]byte, 40), nil)
+	p = decodePayload(PayloadANON_REQ, make([]byte, 40), nil, false)
 	if p.Type != "ANON_REQ" {
 		t.Errorf("ANON_REQ: type=%s", p.Type)
 	}
 
 	// PATH
-	p = decodePayload(PayloadPATH, make([]byte, 10), nil)
+	p = decodePayload(PayloadPATH, make([]byte, 10), nil, false)
 	if p.Type != "PATH" {
 		t.Errorf("PATH: type=%s", p.Type)
 	}
 
 	// TRACE
-	p = decodePayload(PayloadTRACE, make([]byte, 20), nil)
+	p = decodePayload(PayloadTRACE, make([]byte, 20), nil, false)
 	if p.Type != "TRACE" {
 		t.Errorf("TRACE: type=%s", p.Type)
 	}
@@ -925,7 +928,7 @@ func TestComputeContentHashLongFallback(t *testing.T) {
 
 func TestDecodePacketWithWhitespace(t *testing.T) {
 	raw := "0A 00 D6 9F D7 A5 A7 47 5D B0 73 37 74 9A E6 1F A5 3A 47 88 E9 76"
-	pkt, err := DecodePacket(raw, nil)
+	pkt, err := DecodePacket(raw, nil, false)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -936,7 +939,7 @@ func TestDecodePacketWithWhitespace(t *testing.T) {
 
 func TestDecodePacketWithNewlines(t *testing.T) {
 	raw := "0A00\nD69F\r\nD7A5A7475DB07337749AE61FA53A4788E976"
-	pkt, err := DecodePacket(raw, nil)
+	pkt, err := DecodePacket(raw, nil, false)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -947,7 +950,7 @@ func TestDecodePacketWithNewlines(t *testing.T) {
 
 func TestDecodePacketTransportRouteTooShort(t *testing.T) {
 	// TRANSPORT_FLOOD (route=0) but only 2 bytes total → too short for transport codes
-	_, err := DecodePacket("1400", nil)
+	_, err := DecodePacket("1400", nil, false)
 	if err == nil {
 		t.Error("expected error for transport route with too-short buffer")
 	}
@@ -1007,7 +1010,7 @@ func TestDecodeHeaderUnknownTypes(t *testing.T) {
 
 func TestDecodePayloadMultipart(t *testing.T) {
 	// MULTIPART (0x0A) falls through to default → UNKNOWN
-	p := decodePayload(PayloadMULTIPART, []byte{0x01, 0x02}, nil)
+	p := decodePayload(PayloadMULTIPART, []byte{0x01, 0x02}, nil, false)
 	if p.Type != "UNKNOWN" {
 		t.Errorf("MULTIPART type=%s, want UNKNOWN", p.Type)
 	}
@@ -1015,7 +1018,7 @@ func TestDecodePayloadMultipart(t *testing.T) {
 
 func TestDecodePayloadControl(t *testing.T) {
 	// CONTROL (0x0B) falls through to default → UNKNOWN
-	p := decodePayload(PayloadCONTROL, []byte{0x01, 0x02}, nil)
+	p := decodePayload(PayloadCONTROL, []byte{0x01, 0x02}, nil, false)
 	if p.Type != "UNKNOWN" {
 		t.Errorf("CONTROL type=%s, want UNKNOWN", p.Type)
 	}
@@ -1039,7 +1042,7 @@ func TestDecodePathTruncatedBuffer(t *testing.T) {
 func TestDecodeFloodAdvert5Hops(t *testing.T) {
 	// From test-decoder.js Test 1
 	raw := "11451000D818206D3AAC152C8A91F89957E6D30CA51F36E28790228971C473B755F244F718754CF5EE4A2FD58D944466E42CDED140C66D0CC590183E32BAF40F112BE8F3F2BDF6012B4B2793C52F1D36F69EE054D9A05593286F78453E56C0EC4A3EB95DDA2A7543FCCC00B939CACC009278603902FC12BCF84B706120526F6F6620536F6C6172"
-	pkt, err := DecodePacket(raw, nil)
+	pkt, err := DecodePacket(raw, nil, false)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -1410,7 +1413,7 @@ func TestDecodeAdvertWithTelemetry(t *testing.T) {
 		name + nullTerm +
 		hex.EncodeToString(batteryLE) + hex.EncodeToString(tempLE)
 
-	pkt, err := DecodePacket(hexStr, nil)
+	pkt, err := DecodePacket(hexStr, nil, false)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -1449,7 +1452,7 @@ func TestDecodeAdvertWithTelemetryNegativeTemp(t *testing.T) {
 		name + nullTerm +
 		hex.EncodeToString(batteryLE) + hex.EncodeToString(tempLE)
 
-	pkt, err := DecodePacket(hexStr, nil)
+	pkt, err := DecodePacket(hexStr, nil, false)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -1476,7 +1479,7 @@ func TestDecodeAdvertWithoutTelemetry(t *testing.T) {
 	name := hex.EncodeToString([]byte("Node1"))
 
 	hexStr := "1200" + pubkey + timestamp + signature + flags + name
-	pkt, err := DecodePacket(hexStr, nil)
+	pkt, err := DecodePacket(hexStr, nil, false)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -1503,7 +1506,7 @@ func TestDecodeAdvertNonSensorIgnoresTelemetryBytes(t *testing.T) {
 	extraBytes := "B40ED403" // battery-like and temp-like bytes
 
 	hexStr := "1200" + pubkey + timestamp + signature + flags + name + nullTerm + extraBytes
-	pkt, err := DecodePacket(hexStr, nil)
+	pkt, err := DecodePacket(hexStr, nil, false)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -1531,7 +1534,7 @@ func TestDecodeAdvertTelemetryZeroTemp(t *testing.T) {
 		name + nullTerm +
 		hex.EncodeToString(batteryLE) + hex.EncodeToString(tempLE)
 
-	pkt, err := DecodePacket(hexStr, nil)
+	pkt, err := DecodePacket(hexStr, nil, false)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -1542,3 +1545,153 @@ func TestDecodeAdvertTelemetryZeroTemp(t *testing.T) {
 		t.Errorf("temperature_c=%f, want 0.0", *pkt.Payload.TemperatureC)
 	}
 }
+
+func repeatHex(byteHex string, n int) string {
+	s := ""
+	for i := 0; i < n; i++ {
+		s += byteHex
+	}
+	return s
+}
+
+func TestZeroHopDirectHashSize(t *testing.T) {
+	// DIRECT (RouteType=2) + REQ (PayloadType=0) → header byte = 0x02
+	// pathByte=0x00 → hash_count=0, hash_size bits=0 → should get HashSize=0
+	hex := "02" + "00" + repeatHex("AA", 20)
+	pkt, err := DecodePacket(hex, nil, false)
+	if err != nil {
+		t.Fatalf("DecodePacket failed: %v", err)
+	}
+	if pkt.Path.HashSize != 0 {
+		t.Errorf("DIRECT zero-hop: want HashSize=0, got %d", pkt.Path.HashSize)
+	}
+}
+
+func TestZeroHopDirectHashSizeWithNonZeroUpperBits(t *testing.T) {
+	// DIRECT (RouteType=2) + REQ (PayloadType=0) → header byte = 0x02
+	// pathByte=0x40 → hash_count=0, hash_size bits=01 → should still get HashSize=0
+	hex := "02" + "40" + repeatHex("AA", 20)
+	pkt, err := DecodePacket(hex, nil, false)
+	if err != nil {
+		t.Fatalf("DecodePacket failed: %v", err)
+	}
+	if pkt.Path.HashSize != 0 {
+		t.Errorf("DIRECT zero-hop with hash_size bits set: want HashSize=0, got %d", pkt.Path.HashSize)
+	}
+}
+
+func TestNonDirectZeroPathByteKeepsHashSize(t *testing.T) {
+	// FLOOD (RouteType=1) + REQ (PayloadType=0) → header byte = 0x01
+	// pathByte=0x00 → non-DIRECT should keep HashSize=1
+	hex := "01" + "00" + repeatHex("AA", 20)
+	pkt, err := DecodePacket(hex, nil, false)
+	if err != nil {
+		t.Fatalf("DecodePacket failed: %v", err)
+	}
+	if pkt.Path.HashSize != 1 {
+		t.Errorf("FLOOD zero pathByte: want HashSize=1, got %d", pkt.Path.HashSize)
+	}
+}
+
+func TestDirectNonZeroHopKeepsHashSize(t *testing.T) {
+	// DIRECT (RouteType=2) + REQ (PayloadType=0) → header byte = 0x02
+	// pathByte=0x01 → hash_count=1, hash_size=1 → should keep HashSize=1
+	hex := "02" + "01" + repeatHex("BB", 21)
+	pkt, err := DecodePacket(hex, nil, false)
+	if err != nil {
+		t.Fatalf("DecodePacket failed: %v", err)
+	}
+	if pkt.Path.HashSize != 1 {
+		t.Errorf("DIRECT with 1 hop: want HashSize=1, got %d", pkt.Path.HashSize)
+	}
+}
+
+func TestValidateAdvertSignature(t *testing.T) {
+	// Generate a real ed25519 key pair
+	pub, priv, err := ed25519.GenerateKey(nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	var timestamp uint32 = 1234567890
+	appdata := []byte{0x02, 0x11, 0x22} // flags + some data
+
+	// Build the message the same way ValidateAdvertSignature does
+	message := make([]byte, 32+4+len(appdata))
+	copy(message[0:32], pub)
+	binary.LittleEndian.PutUint32(message[32:36], timestamp)
+	copy(message[36:], appdata)
+
+	sig := ed25519.Sign(priv, message)
+
+	// Valid signature
+	if !sigvalidate.ValidateAdvertSignature(pub, sig, timestamp, appdata) {
+		t.Error("expected valid signature")
+	}
+
+	// Tampered appdata → invalid
+	badAppdata := []byte{0x03, 0x11, 0x22}
+	if sigvalidate.ValidateAdvertSignature(pub, sig, timestamp, badAppdata) {
+		t.Error("expected invalid signature with tampered appdata")
+	}
+
+	// Wrong timestamp → invalid
+	if sigvalidate.ValidateAdvertSignature(pub, sig, timestamp+1, appdata) {
+		t.Error("expected invalid signature with wrong timestamp")
+	}
+
+	// Wrong length pubkey → false
+	if sigvalidate.ValidateAdvertSignature([]byte{0xAA, 0xBB}, sig, timestamp, appdata) {
+		t.Error("expected false for short pubkey")
+	}
+
+	// Wrong length signature → false
+	if sigvalidate.ValidateAdvertSignature(pub, []byte{0xAA, 0xBB}, timestamp, appdata) {
+		t.Error("expected false for short signature")
+	}
+}
+
+func TestDecodeAdvertWithSignatureValidation(t *testing.T) {
+	// Generate key pair
+	pub, priv, err := ed25519.GenerateKey(nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	var timestamp uint32 = 1000000
+	appdata := []byte{0x02} // repeater type, no location
+
+	// Build signed message
+	message := make([]byte, 32+4+len(appdata))
+	copy(message[0:32], pub)
+	binary.LittleEndian.PutUint32(message[32:36], timestamp)
+	copy(message[36:], appdata)
+	sig := ed25519.Sign(priv, message)
+
+	// Build advert buffer: pubkey(32) + timestamp(4) + signature(64) + appdata
+	buf := make([]byte, 0, 101)
+	buf = append(buf, pub...)
+	ts := make([]byte, 4)
+	binary.LittleEndian.PutUint32(ts, timestamp)
+	buf = append(buf, ts...)
+	buf = append(buf, sig...)
+	buf = append(buf, appdata...)
+
+	// With validation enabled
+	p := decodeAdvert(buf, true)
+	if p.Error != "" {
+		t.Fatalf("decode error: %s", p.Error)
+	}
+	if p.SignatureValid == nil {
+		t.Fatal("SignatureValid should be set when validation enabled")
+	}
+	if !*p.SignatureValid {
+		t.Error("expected valid signature")
+	}
+
+	// Without validation
+	p2 := decodeAdvert(buf, false)
+	if p2.SignatureValid != nil {
+		t.Error("SignatureValid should be nil when validation disabled")
+	}
+}

cmd/ingestor/go.mod

@@ -5,11 +5,14 @@ go 1.22
 require (
 	github.com/eclipse/paho.mqtt.golang v1.5.0
 	github.com/meshcore-analyzer/geofilter v0.0.0
+	github.com/meshcore-analyzer/sigvalidate v0.0.0-00010101000000-000000000000
 	modernc.org/sqlite v1.34.5
 )
 
 replace github.com/meshcore-analyzer/geofilter => ../../internal/geofilter
 
+replace github.com/meshcore-analyzer/sigvalidate => ../../internal/sigvalidate
+
 require (
 	github.com/dustin/go-humanize v1.0.1 // indirect
 	github.com/google/uuid v1.6.0 // indirect

cmd/ingestor/main.go

@@ -49,11 +49,8 @@ func main() {
 	}
 
 	sources := cfg.ResolvedSources()
-	if len(sources) == 0 {
-		log.Fatal("no MQTT sources configured — set mqttSources in config or MQTT_BROKER env var")
-	}
 
-	store, err := OpenStore(cfg.DBPath)
+	store, err := OpenStoreWithInterval(cfg.DBPath, cfg.MetricsSampleInterval())
 	if err != nil {
 		log.Fatalf("db: %v", err)
 	}
@@ -64,6 +61,10 @@ func main() {
 	nodeDays := cfg.NodeDaysOrDefault()
 	store.MoveStaleNodes(nodeDays)
 
+	// Metrics retention: prune old metrics on startup
+	metricsDays := cfg.MetricsRetentionDays()
+	store.PruneOldMetrics(metricsDays)
+
 	// Daily ticker for node retention
 	retentionTicker := time.NewTicker(1 * time.Hour)
 	go func() {
@@ -72,6 +73,14 @@ func main() {
 		}
 	}()
 
+	// Daily ticker for metrics retention (every 24h)
+	metricsRetentionTicker := time.NewTicker(24 * time.Hour)
+	go func() {
+		for range metricsRetentionTicker.C {
+			store.PruneOldMetrics(metricsDays)
+		}
+	}()
+
 	// Periodic stats logging (every 5 minutes)
 	statsTicker := time.NewTicker(5 * time.Minute)
 	go func() {
@@ -151,7 +160,7 @@ func main() {
 	}
 
 	if len(clients) == 0 {
-		log.Fatal("no MQTT connections established")
+		log.Fatal("no MQTT connections established — check broker is running (default: mqtt://localhost:1883). Set MQTT_BROKER env var or configure mqttSources in config.json")
 	}
 
 	log.Printf("Running — %d MQTT source(s) connected", len(clients))
@@ -163,6 +172,7 @@ func main() {
 
 	log.Println("Shutting down...")
 	retentionTicker.Stop()
+	metricsRetentionTicker.Stop()
 	statsTicker.Stop()
 	store.LogStats() // final stats on shutdown
 	for _, c := range clients {
@@ -215,6 +225,22 @@ func handleMessage(store *Store, tag string, source MQTTSource, m mqtt.Message,
 		if err := store.UpsertObserver(observerID, name, iata, meta); err != nil {
 			log.Printf("MQTT [%s] observer status error: %v", tag, err)
 		}
+		// Insert metrics sample from status message
+		if meta != nil {
+			metricsData := &MetricsData{
+				ObserverID:  observerID,
+				NoiseFloor:  meta.NoiseFloor,
+				TxAirSecs:   meta.TxAirSecs,
+				RxAirSecs:   meta.RxAirSecs,
+				RecvErrors:  meta.RecvErrors,
+				BatteryMv:   meta.BatteryMv,
+				PacketsSent: meta.PacketsSent,
+				PacketsRecv: meta.PacketsRecv,
+			}
+			if err := store.InsertMetrics(metricsData); err != nil {
+				log.Printf("MQTT [%s] metrics insert error: %v", tag, err)
+			}
+		}
 		log.Printf("MQTT [%s] status: %s (%s)", tag, firstNonEmpty(name, observerID), iata)
 		return
 	}
@@ -222,7 +248,7 @@ func handleMessage(store *Store, tag string, source MQTTSource, m mqtt.Message,
 	// Format 1: Raw packet (meshcoretomqtt / Cisien format)
 	rawHex, _ := msg["raw"].(string)
 	if rawHex != "" {
-		decoded, err := DecodePacket(rawHex, channelKeys)
+		decoded, err := DecodePacket(rawHex, channelKeys, false)
 		if err != nil {
 			log.Printf("MQTT [%s] decode error: %v", tag, err)
 			return
@@ -616,6 +642,41 @@ func extractObserverMeta(msg map[string]interface{}) *ObserverMeta {
 			hasData = true
 		}
 	}
+	if v := nestedOrTopLevel(stats, msg, "tx_air_secs"); v != nil {
+		if f, ok := toFloat64(v); ok {
+			iv := int(math.Round(f))
+			meta.TxAirSecs = &iv
+			hasData = true
+		}
+	}
+	if v := nestedOrTopLevel(stats, msg, "rx_air_secs"); v != nil {
+		if f, ok := toFloat64(v); ok {
+			iv := int(math.Round(f))
+			meta.RxAirSecs = &iv
+			hasData = true
+		}
+	}
+	if v := nestedOrTopLevel(stats, msg, "recv_errors"); v != nil {
+		if f, ok := toFloat64(v); ok {
+			iv := int(math.Round(f))
+			meta.RecvErrors = &iv
+			hasData = true
+		}
+	}
+	if v := nestedOrTopLevel(stats, msg, "packets_sent"); v != nil {
+		if f, ok := toFloat64(v); ok {
+			iv := int(math.Round(f))
+			meta.PacketsSent = &iv
+			hasData = true
+		}
+	}
+	if v := nestedOrTopLevel(stats, msg, "packets_recv"); v != nil {
+		if f, ok := toFloat64(v); ok {
+			iv := int(math.Round(f))
+			meta.PacketsRecv = &iv
+			hasData = true
+		}
+	}
 
 	if !hasData {
 		return nil

cmd/server/advert_pubkey_test.go

@@ -0,0 +1,181 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"testing"
+)
+
+// TestAdvertPubkeyTracking verifies that advertPubkeys is maintained
+// incrementally during ingest and eviction, and that GetPerfStoreStats
+// returns the correct count without per-request JSON parsing.
+func TestAdvertPubkeyTracking(t *testing.T) {
+	ps := NewPacketStore(nil, nil)
+	ps.mu.Lock()
+
+	// Helper to create an ADVERT StoreTx with a given pubkey.
+	pt4 := 4
+	mkAdvert := func(id int, pubkey string) *StoreTx {
+		d := map[string]interface{}{"pubKey": pubkey}
+		j, _ := json.Marshal(d)
+		return &StoreTx{
+			ID:          id,
+			Hash:        fmt.Sprintf("hash%d", id),
+			PayloadType: &pt4,
+			DecodedJSON: string(j),
+		}
+	}
+
+	// Add 3 adverts: 2 distinct pubkeys
+	tx1 := mkAdvert(1, "pk_alpha")
+	tx2 := mkAdvert(2, "pk_beta")
+	tx3 := mkAdvert(3, "pk_alpha") // duplicate pubkey
+
+	for _, tx := range []*StoreTx{tx1, tx2, tx3} {
+		ps.packets = append(ps.packets, tx)
+		ps.byHash[tx.Hash] = tx
+		ps.byTxID[tx.ID] = tx
+		ps.byPayloadType[4] = append(ps.byPayloadType[4], tx)
+		ps.trackAdvertPubkey(tx)
+	}
+	ps.mu.Unlock()
+
+	// GetPerfStoreStats should report 2 distinct pubkeys
+	stats := ps.GetPerfStoreStats()
+	indexes := stats["indexes"].(map[string]interface{})
+	got := indexes["advertByObserver"].(int)
+	if got != 2 {
+		t.Errorf("advertByObserver = %d, want 2", got)
+	}
+
+	// GetPerfStoreStatsTyped should agree
+	typed := ps.GetPerfStoreStatsTyped()
+	if typed.Indexes.AdvertByObserver != 2 {
+		t.Errorf("typed AdvertByObserver = %d, want 2", typed.Indexes.AdvertByObserver)
+	}
+
+	// Evict tx3 (pk_alpha duplicate) — count should stay 2
+	ps.mu.Lock()
+	ps.untrackAdvertPubkey(tx3)
+	ps.mu.Unlock()
+
+	stats2 := ps.GetPerfStoreStats()
+	idx2 := stats2["indexes"].(map[string]interface{})
+	if idx2["advertByObserver"].(int) != 2 {
+		t.Errorf("after evicting duplicate: advertByObserver = %d, want 2", idx2["advertByObserver"].(int))
+	}
+
+	// Evict tx1 (last pk_alpha) — count should drop to 1
+	ps.mu.Lock()
+	ps.untrackAdvertPubkey(tx1)
+	ps.mu.Unlock()
+
+	stats3 := ps.GetPerfStoreStats()
+	idx3 := stats3["indexes"].(map[string]interface{})
+	if idx3["advertByObserver"].(int) != 1 {
+		t.Errorf("after evicting last pk_alpha: advertByObserver = %d, want 1", idx3["advertByObserver"].(int))
+	}
+
+	// Evict tx2 (last remaining) — count should be 0
+	ps.mu.Lock()
+	ps.untrackAdvertPubkey(tx2)
+	ps.mu.Unlock()
+
+	stats4 := ps.GetPerfStoreStats()
+	idx4 := stats4["indexes"].(map[string]interface{})
+	if idx4["advertByObserver"].(int) != 0 {
+		t.Errorf("after evicting all: advertByObserver = %d, want 0", idx4["advertByObserver"].(int))
+	}
+}
+
+// TestAdvertPubkeyPublicKeyField tests the "public_key" JSON field variant.
+func TestAdvertPubkeyPublicKeyField(t *testing.T) {
+	ps := NewPacketStore(nil, nil)
+	ps.mu.Lock()
+	pt4 := 4
+	d, _ := json.Marshal(map[string]interface{}{"public_key": "pk_legacy"})
+	tx := &StoreTx{ID: 1, Hash: "h1", PayloadType: &pt4, DecodedJSON: string(d)}
+	ps.trackAdvertPubkey(tx)
+	ps.mu.Unlock()
+
+	stats := ps.GetPerfStoreStats()
+	idx := stats["indexes"].(map[string]interface{})
+	if idx["advertByObserver"].(int) != 1 {
+		t.Errorf("public_key field: advertByObserver = %d, want 1", idx["advertByObserver"].(int))
+	}
+}
+
+// TestAdvertPubkeyNonAdvert ensures non-ADVERT packets don't affect the count.
+func TestAdvertPubkeyNonAdvert(t *testing.T) {
+	ps := NewPacketStore(nil, nil)
+	ps.mu.Lock()
+	pt2 := 2
+	d, _ := json.Marshal(map[string]interface{}{"pubKey": "pk_text"})
+	tx := &StoreTx{ID: 1, Hash: "h1", PayloadType: &pt2, DecodedJSON: string(d)}
+	ps.trackAdvertPubkey(tx)
+	ps.mu.Unlock()
+
+	stats := ps.GetPerfStoreStats()
+	idx := stats["indexes"].(map[string]interface{})
+	if idx["advertByObserver"].(int) != 0 {
+		t.Errorf("non-ADVERT should not be tracked: advertByObserver = %d, want 0", idx["advertByObserver"].(int))
+	}
+}
+
+// BenchmarkGetPerfStoreStats benchmarks the perf stats endpoint with many adverts.
+// Before the fix, this did O(N) JSON unmarshals per call.
+// After the fix, it's O(1) — just len(map).
+func BenchmarkGetPerfStoreStats(b *testing.B) {
+	ps := NewPacketStore(nil, nil)
+	ps.mu.Lock()
+	pt4 := 4
+	for i := 0; i < 5000; i++ {
+		pk := fmt.Sprintf("pk_%04d", i%200) // 200 distinct pubkeys
+		d, _ := json.Marshal(map[string]interface{}{"pubKey": pk})
+		tx := &StoreTx{
+			ID:          i + 1,
+			Hash:        fmt.Sprintf("hash%d", i+1),
+			PayloadType: &pt4,
+			DecodedJSON: string(d),
+		}
+		ps.packets = append(ps.packets, tx)
+		ps.byHash[tx.Hash] = tx
+		ps.byTxID[tx.ID] = tx
+		ps.byPayloadType[4] = append(ps.byPayloadType[4], tx)
+		ps.trackAdvertPubkey(tx)
+	}
+	ps.mu.Unlock()
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		ps.GetPerfStoreStats()
+	}
+}
+
+// BenchmarkGetPerfStoreStatsTyped benchmarks the typed variant.
+func BenchmarkGetPerfStoreStatsTyped(b *testing.B) {
+	ps := NewPacketStore(nil, nil)
+	ps.mu.Lock()
+	pt4 := 4
+	for i := 0; i < 5000; i++ {
+		pk := fmt.Sprintf("pk_%04d", i%200)
+		d, _ := json.Marshal(map[string]interface{}{"pubKey": pk})
+		tx := &StoreTx{
+			ID:          i + 1,
+			Hash:        fmt.Sprintf("hash%d", i+1),
+			PayloadType: &pt4,
+			DecodedJSON: string(d),
+		}
+		ps.packets = append(ps.packets, tx)
+		ps.byHash[tx.Hash] = tx
+		ps.byTxID[tx.ID] = tx
+		ps.byPayloadType[4] = append(ps.byPayloadType[4], tx)
+		ps.trackAdvertPubkey(tx)
+	}
+	ps.mu.Unlock()
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		ps.GetPerfStoreStatsTyped()
+	}
+}

cmd/server/apikey_security_test.go

@@ -0,0 +1,111 @@
+package main
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+)
+
+func TestIsWeakAPIKey(t *testing.T) {
+	// Known defaults must be detected
+	for _, weak := range []string{
+		"your-secret-api-key-here", "change-me", "example", "test",
+		"password", "admin", "apikey", "api-key", "secret", "default",
+	} {
+		if !IsWeakAPIKey(weak) {
+			t.Errorf("expected %q to be weak", weak)
+		}
+	}
+	// Case-insensitive
+	if !IsWeakAPIKey("Password") {
+		t.Error("expected case-insensitive match for Password")
+	}
+	if !IsWeakAPIKey("YOUR-SECRET-API-KEY-HERE") {
+		t.Error("expected case-insensitive match")
+	}
+
+	// Short keys (<16 chars) are weak
+	if !IsWeakAPIKey("short") {
+		t.Error("expected short key to be weak")
+	}
+	if !IsWeakAPIKey("exactly15chars!") { // 15 chars
+		t.Error("expected 15-char key to be weak")
+	}
+
+	// Empty key is NOT weak (handled separately as "disabled")
+	if IsWeakAPIKey("") {
+		t.Error("empty key should not be flagged as weak")
+	}
+
+	// Strong keys pass
+	if IsWeakAPIKey("a-very-strong-key-1234") {
+		t.Error("expected strong key to pass")
+	}
+	if IsWeakAPIKey("xK9!mP2@nL5#qR8$") {
+		t.Error("expected 17-char random key to pass")
+	}
+}
+
+func TestRequireAPIKey_RejectsWeakKey(t *testing.T) {
+	s := &Server{cfg: &Config{APIKey: "test"}}
+	handler := s.requireAPIKey(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusOK)
+	}))
+
+	req := httptest.NewRequest("POST", "/api/packets", nil)
+	req.Header.Set("X-API-Key", "test")
+	rr := httptest.NewRecorder()
+	handler.ServeHTTP(rr, req)
+
+	if rr.Code != http.StatusForbidden {
+		t.Errorf("expected 403 for weak key, got %d", rr.Code)
+	}
+}
+
+func TestRequireAPIKey_AcceptsStrongKey(t *testing.T) {
+	strongKey := "a-very-strong-key-1234"
+	s := &Server{cfg: &Config{APIKey: strongKey}}
+	handler := s.requireAPIKey(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusOK)
+	}))
+
+	req := httptest.NewRequest("POST", "/api/packets", nil)
+	req.Header.Set("X-API-Key", strongKey)
+	rr := httptest.NewRecorder()
+	handler.ServeHTTP(rr, req)
+
+	if rr.Code != http.StatusOK {
+		t.Errorf("expected 200 for strong key, got %d", rr.Code)
+	}
+}
+
+func TestRequireAPIKey_EmptyKeyDisablesEndpoints(t *testing.T) {
+	s := &Server{cfg: &Config{APIKey: ""}}
+	handler := s.requireAPIKey(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusOK)
+	}))
+
+	req := httptest.NewRequest("POST", "/api/packets", nil)
+	rr := httptest.NewRecorder()
+	handler.ServeHTTP(rr, req)
+
+	if rr.Code != http.StatusForbidden {
+		t.Errorf("expected 403 for empty key, got %d", rr.Code)
+	}
+}
+
+func TestRequireAPIKey_WrongKeyUnauthorized(t *testing.T) {
+	s := &Server{cfg: &Config{APIKey: "a-very-strong-key-1234"}}
+	handler := s.requireAPIKey(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusOK)
+	}))
+
+	req := httptest.NewRequest("POST", "/api/packets", nil)
+	req.Header.Set("X-API-Key", "wrong-key-entirely-here")
+	rr := httptest.NewRecorder()
+	handler.ServeHTTP(rr, req)
+
+	if rr.Code != http.StatusUnauthorized {
+		t.Errorf("expected 401 for wrong key, got %d", rr.Code)
+	}
+}

cmd/server/backfill_async_test.go

@@ -0,0 +1,132 @@
+package main
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+	"time"
+
+	"github.com/gorilla/mux"
+)
+
+// TestBackfillAsyncChunked verifies that backfillResolvedPathsAsync processes
+// observations in chunks, yields between batches, and sets the completion flag.
+func TestBackfillAsyncChunked(t *testing.T) {
+	store := &PacketStore{
+		packets:  make([]*StoreTx, 0),
+		byHash:   make(map[string]*StoreTx),
+		byTxID:   make(map[int]*StoreTx),
+		byObsID:  make(map[int]*StoreObs),
+	}
+
+	// No pending observations → should complete immediately.
+	backfillResolvedPathsAsync(store, "", 100, time.Millisecond, 24)
+	if !store.backfillComplete.Load() {
+		t.Fatal("expected backfillComplete to be true with empty store")
+	}
+}
+
+// TestBackfillStatusHeader verifies the X-CoreScope-Status header is set correctly.
+func TestBackfillStatusHeader(t *testing.T) {
+	store := &PacketStore{
+		packets: make([]*StoreTx, 0),
+		byHash:  make(map[string]*StoreTx),
+		byTxID:  make(map[int]*StoreTx),
+		byObsID: make(map[int]*StoreObs),
+	}
+
+	srv := &Server{store: store}
+
+	handler := srv.backfillStatusMiddleware(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(200)
+	}))
+
+	// Before backfill completes → backfilling
+	req := httptest.NewRequest("GET", "/api/stats", nil)
+	rec := httptest.NewRecorder()
+	handler.ServeHTTP(rec, req)
+	if got := rec.Header().Get("X-CoreScope-Status"); got != "backfilling" {
+		t.Fatalf("expected 'backfilling', got %q", got)
+	}
+
+	// After backfill completes → ready
+	store.backfillComplete.Store(true)
+	rec = httptest.NewRecorder()
+	handler.ServeHTTP(rec, req)
+	if got := rec.Header().Get("X-CoreScope-Status"); got != "ready" {
+		t.Fatalf("expected 'ready', got %q", got)
+	}
+}
+
+// TestStatsBackfillFields verifies /api/stats includes backfill fields.
+func TestStatsBackfillFields(t *testing.T) {
+	db := setupTestDBv2(t)
+	defer db.Close()
+	seedV2Data(t, db)
+
+	store := &PacketStore{
+		db:      db,
+		packets: make([]*StoreTx, 0),
+		byHash:  make(map[string]*StoreTx),
+		byTxID:  make(map[int]*StoreTx),
+		byObsID: make(map[int]*StoreObs),
+		loaded:  true,
+	}
+
+	cfg := &Config{Port: 0}
+	hub := NewHub()
+	srv := NewServer(db, cfg, hub)
+	srv.store = store
+
+	router := mux.NewRouter()
+	srv.RegisterRoutes(router)
+
+	// While backfilling
+	req := httptest.NewRequest("GET", "/api/stats", nil)
+	rec := httptest.NewRecorder()
+	router.ServeHTTP(rec, req)
+
+	var resp map[string]interface{}
+	if err := json.Unmarshal(rec.Body.Bytes(), &resp); err != nil {
+		t.Fatalf("failed to parse stats response: %v", err)
+	}
+
+	if backfilling, ok := resp["backfilling"]; !ok {
+		t.Fatal("missing 'backfilling' field in stats response")
+	} else if backfilling != true {
+		t.Fatalf("expected backfilling=true, got %v", backfilling)
+	}
+
+	if _, ok := resp["backfillProgress"]; !ok {
+		t.Fatal("missing 'backfillProgress' field in stats response")
+	}
+
+	// Check header
+	if got := rec.Header().Get("X-CoreScope-Status"); got != "backfilling" {
+		t.Fatalf("expected X-CoreScope-Status=backfilling, got %q", got)
+	}
+
+	// After backfill completes
+	store.backfillComplete.Store(true)
+	// Invalidate stats cache
+	srv.statsMu.Lock()
+	srv.statsCache = nil
+	srv.statsMu.Unlock()
+
+	rec = httptest.NewRecorder()
+	router.ServeHTTP(rec, req)
+
+	resp = nil
+	if err := json.Unmarshal(rec.Body.Bytes(), &resp); err != nil {
+		t.Fatalf("failed to parse stats response: %v", err)
+	}
+
+	if backfilling, ok := resp["backfilling"]; !ok || backfilling != false {
+		t.Fatalf("expected backfilling=false after completion, got %v", backfilling)
+	}
+
+	if got := rec.Header().Get("X-CoreScope-Status"); got != "ready" {
+		t.Fatalf("expected X-CoreScope-Status=ready, got %q", got)
+	}
+}

cmd/server/cache_invalidation_test.go

@@ -16,6 +16,7 @@ func newTestStore(t *testing.T) *PacketStore {
 		distCache:    make(map[string]*cachedResult),
 		subpathCache: make(map[string]*cachedResult),
 		rfCacheTTL:   15 * time.Second,
+		invCooldown:  10 * time.Second,
 	}
 }
 
@@ -169,3 +170,164 @@ func TestInvalidateCachesFor_NoFlags(t *testing.T) {
 		}
 	}
 }
+
+// TestInvalidationRateLimited verifies that rapid ingest cycles don't clear
+// caches immediately — they accumulate dirty flags during the cooldown period
+// and apply them on the next call after cooldown expires (fixes #533).
+func TestInvalidationRateLimited(t *testing.T) {
+	s := newTestStore(t)
+	s.invCooldown = 100 * time.Millisecond // short cooldown for testing
+
+	// First invalidation should go through immediately
+	populateAllCaches(s)
+	s.invalidateCachesFor(cacheInvalidation{hasNewObservations: true})
+	state := cachePopulated(s)
+	if state["rf"] {
+		t.Error("rf cache should be cleared on first invalidation")
+	}
+	if !state["topo"] {
+		t.Error("topo cache should survive (no path changes)")
+	}
+
+	// Repopulate and call again within cooldown — should NOT clear
+	populateAllCaches(s)
+	s.invalidateCachesFor(cacheInvalidation{hasNewObservations: true})
+	state = cachePopulated(s)
+	if !state["rf"] {
+		t.Error("rf cache should survive during cooldown period")
+	}
+
+	// Wait for cooldown to expire
+	time.Sleep(150 * time.Millisecond)
+
+	// Next call should apply accumulated + current flags
+	populateAllCaches(s)
+	s.invalidateCachesFor(cacheInvalidation{hasNewPaths: true})
+	state = cachePopulated(s)
+	if state["rf"] {
+		t.Error("rf cache should be cleared (pending from cooldown)")
+	}
+	if state["topo"] {
+		t.Error("topo cache should be cleared (current call has hasNewPaths)")
+	}
+	if !state["hash"] {
+		t.Error("hash cache should survive (no transmission changes)")
+	}
+}
+
+// TestInvalidationCooldownAccumulatesFlags verifies that multiple calls during
+// cooldown merge their flags correctly.
+func TestInvalidationCooldownAccumulatesFlags(t *testing.T) {
+	s := newTestStore(t)
+	s.invCooldown = 200 * time.Millisecond
+
+	// Initial invalidation (goes through, starts cooldown)
+	s.invalidateCachesFor(cacheInvalidation{hasNewObservations: true})
+
+	// Several calls during cooldown with different flags
+	s.invalidateCachesFor(cacheInvalidation{hasNewPaths: true})
+	s.invalidateCachesFor(cacheInvalidation{hasNewTransmissions: true})
+	s.invalidateCachesFor(cacheInvalidation{hasChannelData: true})
+
+	// Verify pending has all flags
+	s.cacheMu.Lock()
+	if s.pendingInv == nil {
+		t.Fatal("pendingInv should not be nil during cooldown")
+	}
+	if !s.pendingInv.hasNewPaths || !s.pendingInv.hasNewTransmissions || !s.pendingInv.hasChannelData {
+		t.Error("all flags should be accumulated in pendingInv")
+	}
+	// hasNewObservations was applied immediately, not accumulated
+	if s.pendingInv.hasNewObservations {
+		t.Error("hasNewObservations was already applied, should not be in pending")
+	}
+	s.cacheMu.Unlock()
+
+	// Wait for cooldown, then trigger — all accumulated flags should apply
+	time.Sleep(250 * time.Millisecond)
+	populateAllCaches(s)
+	s.invalidateCachesFor(cacheInvalidation{}) // empty trigger
+	state := cachePopulated(s)
+
+	// Pending had paths, transmissions, channels — all those caches should clear
+	if state["topo"] {
+		t.Error("topo should be cleared (pending hasNewPaths)")
+	}
+	if state["hash"] {
+		t.Error("hash should be cleared (pending hasNewTransmissions)")
+	}
+	if state["chan"] {
+		t.Error("chan should be cleared (pending hasChannelData)")
+	}
+}
+
+// TestEvictionBypassesCooldown verifies eviction always clears immediately.
+func TestEvictionBypassesCooldown(t *testing.T) {
+	s := newTestStore(t)
+	s.invCooldown = 10 * time.Second // long cooldown
+
+	// Start cooldown
+	s.invalidateCachesFor(cacheInvalidation{hasNewObservations: true})
+
+	// Eviction during cooldown should still clear everything
+	populateAllCaches(s)
+	s.invalidateCachesFor(cacheInvalidation{eviction: true})
+	state := cachePopulated(s)
+	for name, has := range state {
+		if has {
+			t.Errorf("%s cache should be cleared on eviction even during cooldown", name)
+		}
+	}
+	// pendingInv should be cleared
+	s.cacheMu.Lock()
+	if s.pendingInv != nil {
+		t.Error("pendingInv should be nil after eviction")
+	}
+	s.cacheMu.Unlock()
+}
+
+// BenchmarkCacheHitDuringIngestion simulates rapid ingestion and verifies
+// that cache hits now occur thanks to rate-limited invalidation.
+func BenchmarkCacheHitDuringIngestion(b *testing.B) {
+	s := &PacketStore{
+		rfCache:      make(map[string]*cachedResult),
+		topoCache:    make(map[string]*cachedResult),
+		hashCache:    make(map[string]*cachedResult),
+		chanCache:    make(map[string]*cachedResult),
+		distCache:    make(map[string]*cachedResult),
+		subpathCache: make(map[string]*cachedResult),
+		rfCacheTTL:   15 * time.Second,
+		invCooldown:  50 * time.Millisecond,
+	}
+
+	// Trigger first invalidation to start cooldown timer
+	s.invalidateCachesFor(cacheInvalidation{hasNewObservations: true})
+
+	var hits, misses int64
+	for i := 0; i < b.N; i++ {
+		// Populate cache (simulates an analytics query filling the cache)
+		s.cacheMu.Lock()
+		s.rfCache["global"] = &cachedResult{
+			data:      map[string]interface{}{"test": true},
+			expiresAt: time.Now().Add(time.Hour),
+		}
+		s.cacheMu.Unlock()
+
+		// Simulate rapid ingest invalidation (should be rate-limited)
+		s.invalidateCachesFor(cacheInvalidation{hasNewObservations: true})
+
+		// Check if cache survived the invalidation
+		s.cacheMu.Lock()
+		if len(s.rfCache) > 0 {
+			hits++
+		} else {
+			misses++
+		}
+		s.cacheMu.Unlock()
+	}
+
+	if hits == 0 {
+		b.Errorf("expected cache hits > 0 with rate-limited invalidation, got 0 hits / %d misses", misses)
+	}
+	b.ReportMetric(float64(hits)/float64(hits+misses)*100, "hit%")
+}

cmd/server/config.go

@@ -55,6 +55,49 @@ type Config struct {
 	GeoFilter *GeoFilterConfig `json:"geo_filter,omitempty"`
 
 	Timestamps *TimestampConfig `json:"timestamps,omitempty"`
+
+	DebugAffinity bool `json:"debugAffinity,omitempty"`
+
+	ResolvedPath  *ResolvedPathConfig  `json:"resolvedPath,omitempty"`
+	NeighborGraph *NeighborGraphConfig `json:"neighborGraph,omitempty"`
+}
+
+// weakAPIKeys is the blocklist of known default/example API keys that must be rejected.
+var weakAPIKeys = map[string]bool{
+	"your-secret-api-key-here": true,
+	"change-me":                true,
+	"example":                  true,
+	"test":                     true,
+	"password":                 true,
+	"admin":                    true,
+	"apikey":                   true,
+	"api-key":                  true,
+	"secret":                   true,
+	"default":                  true,
+}
+
+// IsWeakAPIKey returns true if the key is in the blocklist or shorter than 16 characters.
+func IsWeakAPIKey(key string) bool {
+	if key == "" {
+		return false // empty is handled separately (endpoints disabled)
+	}
+	if weakAPIKeys[strings.ToLower(key)] {
+		return true
+	}
+	if len(key) < 16 {
+		return true
+	}
+	return false
+}
+
+// ResolvedPathConfig controls async backfill behavior.
+type ResolvedPathConfig struct {
+	BackfillHours int `json:"backfillHours"` // how far back (hours) to scan for NULL resolved_path (default 24)
+}
+
+// NeighborGraphConfig controls neighbor edge pruning.
+type NeighborGraphConfig struct {
+	MaxAgeDays int `json:"maxAgeDays"` // edges older than this are pruned (default 5)
 }
 
 // PacketStoreConfig controls in-memory packet store limits.
@@ -67,10 +110,34 @@ type PacketStoreConfig struct {
 type GeoFilterConfig = geofilter.Config
 
 type RetentionConfig struct {
-	NodeDays   int `json:"nodeDays"`
-	PacketDays int `json:"packetDays"`
+	NodeDays    int `json:"nodeDays"`
+	PacketDays  int `json:"packetDays"`
+	MetricsDays int `json:"metricsDays"`
 }
 
+// MetricsRetentionDays returns configured metrics retention or 30 days default.
+func (c *Config) MetricsRetentionDays() int {
+	if c.Retention != nil && c.Retention.MetricsDays > 0 {
+		return c.Retention.MetricsDays
+	}
+	return 30
+}
+
+// BackfillHours returns configured backfill window or 24h default.
+func (c *Config) BackfillHours() int {
+	if c.ResolvedPath != nil && c.ResolvedPath.BackfillHours > 0 {
+		return c.ResolvedPath.BackfillHours
+	}
+	return 24
+}
+
+// NeighborMaxAgeDays returns configured max edge age or 30 days default.
+func (c *Config) NeighborMaxAgeDays() int {
+	if c.NeighborGraph != nil && c.NeighborGraph.MaxAgeDays > 0 {
+		return c.NeighborGraph.MaxAgeDays
+	}
+	return 5
+}
 
 type TimestampConfig struct {
 	DefaultMode       string `json:"defaultMode"`       // "ago" | "absolute"

cmd/server/config_knobs_test.go

@@ -0,0 +1,177 @@
+package main
+
+import (
+	"database/sql"
+	"path/filepath"
+	"testing"
+	"time"
+
+	_ "modernc.org/sqlite"
+)
+
+func TestBackfillHoursDefault(t *testing.T) {
+	cfg := &Config{}
+	if got := cfg.BackfillHours(); got != 24 {
+		t.Errorf("BackfillHours() = %d, want 24", got)
+	}
+}
+
+func TestBackfillHoursConfigured(t *testing.T) {
+	cfg := &Config{ResolvedPath: &ResolvedPathConfig{BackfillHours: 48}}
+	if got := cfg.BackfillHours(); got != 48 {
+		t.Errorf("BackfillHours() = %d, want 48", got)
+	}
+}
+
+func TestBackfillHoursZeroFallsBack(t *testing.T) {
+	cfg := &Config{ResolvedPath: &ResolvedPathConfig{BackfillHours: 0}}
+	if got := cfg.BackfillHours(); got != 24 {
+		t.Errorf("BackfillHours() = %d, want 24 (default for zero)", got)
+	}
+}
+
+func TestNeighborMaxAgeDaysDefault(t *testing.T) {
+	cfg := &Config{}
+	if got := cfg.NeighborMaxAgeDays(); got != 5 {
+		t.Errorf("NeighborMaxAgeDays() = %d, want 5", got)
+	}
+}
+
+func TestNeighborMaxAgeDaysConfigured(t *testing.T) {
+	cfg := &Config{NeighborGraph: &NeighborGraphConfig{MaxAgeDays: 7}}
+	if got := cfg.NeighborMaxAgeDays(); got != 7 {
+		t.Errorf("NeighborMaxAgeDays() = %d, want 7", got)
+	}
+}
+
+func TestGraphPruneOlderThan(t *testing.T) {
+	g := NewNeighborGraph()
+	now := time.Now().UTC()
+
+	// Add a recent edge
+	g.upsertEdge("aaa", "bbb", "bb", "obs1", nil, now)
+	// Add an old edge
+	g.upsertEdge("ccc", "ddd", "dd", "obs1", nil, now.Add(-60*24*time.Hour))
+
+	if len(g.AllEdges()) != 2 {
+		t.Fatalf("expected 2 edges, got %d", len(g.AllEdges()))
+	}
+
+	cutoff := now.Add(-30 * 24 * time.Hour)
+	pruned := g.PruneOlderThan(cutoff)
+	if pruned != 1 {
+		t.Errorf("PruneOlderThan pruned %d, want 1", pruned)
+	}
+
+	edges := g.AllEdges()
+	if len(edges) != 1 {
+		t.Fatalf("expected 1 edge after prune, got %d", len(edges))
+	}
+	if edges[0].NodeA != "aaa" && edges[0].NodeB != "aaa" {
+		t.Errorf("wrong edge survived prune: %+v", edges[0])
+	}
+}
+
+func TestPruneNeighborEdgesDB(t *testing.T) {
+	tmpDir := t.TempDir()
+	dbPath := filepath.Join(tmpDir, "test.db")
+	db, err := sql.Open("sqlite", "file:"+dbPath+"?_journal_mode=WAL")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	_, err = db.Exec(`CREATE TABLE neighbor_edges (
+		node_a TEXT NOT NULL,
+		node_b TEXT NOT NULL,
+		count INTEGER DEFAULT 1,
+		last_seen TEXT,
+		PRIMARY KEY (node_a, node_b)
+	)`)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	now := time.Now().UTC()
+	old := now.Add(-60 * 24 * time.Hour)
+
+	db.Exec("INSERT INTO neighbor_edges (node_a, node_b, count, last_seen) VALUES (?, ?, 5, ?)",
+		"aaa", "bbb", now.Format(time.RFC3339))
+	db.Exec("INSERT INTO neighbor_edges (node_a, node_b, count, last_seen) VALUES (?, ?, 3, ?)",
+		"ccc", "ddd", old.Format(time.RFC3339))
+
+	g := NewNeighborGraph()
+	g.upsertEdge("aaa", "bbb", "bb", "obs1", nil, now)
+	g.upsertEdge("ccc", "ddd", "dd", "obs1", nil, old)
+
+	pruned, err := PruneNeighborEdges(dbPath, g, 30)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if pruned != 1 {
+		t.Errorf("PruneNeighborEdges pruned %d DB rows, want 1", pruned)
+	}
+
+	var count int
+	db.QueryRow("SELECT COUNT(*) FROM neighbor_edges").Scan(&count)
+	if count != 1 {
+		t.Errorf("expected 1 row in DB after prune, got %d", count)
+	}
+
+	if len(g.AllEdges()) != 1 {
+		t.Errorf("expected 1 in-memory edge after prune, got %d", len(g.AllEdges()))
+	}
+}
+
+func TestBackfillRespectsHourWindow(t *testing.T) {
+	store := &PacketStore{}
+
+	now := time.Now().UTC()
+	oldTime := now.Add(-48 * time.Hour).Format(time.RFC3339Nano)
+	newTime := now.Add(-30 * time.Minute).Format(time.RFC3339Nano)
+
+	store.packets = []*StoreTx{
+		{
+			ID:        1,
+			Hash:      "old-hash",
+			FirstSeen: oldTime,
+			Observations: []*StoreObs{
+				{ID: 1, PathJSON: `["abc"]`},
+			},
+		},
+		{
+			ID:        2,
+			Hash:      "new-hash",
+			FirstSeen: newTime,
+			Observations: []*StoreObs{
+				{ID: 2, PathJSON: `["def"]`},
+			},
+		},
+	}
+
+	// With a 1-hour window, only the new tx should be processed.
+	// backfillResolvedPathsAsync will find no prefix map and finish quickly,
+	// but we can verify the pending count reflects the window.
+	go backfillResolvedPathsAsync(store, "", 100, time.Millisecond, 1)
+
+	// Wait for completion
+	for i := 0; i < 100; i++ {
+		if store.backfillComplete.Load() {
+			break
+		}
+		time.Sleep(10 * time.Millisecond)
+	}
+
+	if !store.backfillComplete.Load() {
+		t.Fatal("backfill did not complete")
+	}
+
+	// With no prefix map, total should be 0 (early exit) or just the new one
+	// The function exits early when pm == nil, so backfillTotal stays at 0
+	// if there were pending items but no pm. Let's verify it didn't process
+	// the old one by checking total <= 1.
+	total := store.backfillTotal.Load()
+	if total > 1 {
+		t.Errorf("backfill total = %d, want <= 1 (old tx should be excluded by hour window)", total)
+	}
+}

cmd/server/coverage_test.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+	"bytes"
 	"database/sql"
 	"encoding/json"
 	"fmt"
@@ -428,6 +429,49 @@ func TestMaxTransmissionID(t *testing.T) {
 	})
 }
 
+// --- MaxTransmissionID incremental tracking ---
+
+func TestMaxTransmissionIDIncremental(t *testing.T) {
+	db := setupTestDB(t)
+	defer db.Close()
+	seedTestData(t, db)
+	store := NewPacketStore(db, nil)
+	store.Load()
+
+	maxTx := store.MaxTransmissionID()
+	maxObs := store.MaxObservationID()
+
+	if maxTx <= 0 {
+		t.Fatalf("expected maxTx > 0 after Load, got %d", maxTx)
+	}
+	if maxObs <= 0 {
+		t.Fatalf("expected maxObs > 0 after Load, got %d", maxObs)
+	}
+
+	// Verify incremental field matches brute-force iteration
+	store.mu.RLock()
+	bruteMaxTx := 0
+	for id := range store.byTxID {
+		if id > bruteMaxTx {
+			bruteMaxTx = id
+		}
+	}
+	bruteMaxObs := 0
+	for id := range store.byObsID {
+		if id > bruteMaxObs {
+			bruteMaxObs = id
+		}
+	}
+	store.mu.RUnlock()
+
+	if maxTx != bruteMaxTx {
+		t.Errorf("maxTxID mismatch: incremental=%d brute=%d", maxTx, bruteMaxTx)
+	}
+	if maxObs != bruteMaxObs {
+		t.Errorf("maxObsID mismatch: incremental=%d brute=%d", maxObs, bruteMaxObs)
+	}
+}
+
 // --- Route handler DB fallback (no store) ---
 
 func TestHandleBulkHealthNoStore(t *testing.T) {
@@ -770,6 +814,56 @@ func TestPrefixMapResolve(t *testing.T) {
 	})
 }
 
+func TestPrefixMapCap(t *testing.T) {
+	// 16-char pubkey — longer than maxPrefixLen
+	nodes := []nodeInfo{
+		{PublicKey: "aabbccdd11223344", Name: "LongKey"},
+		{PublicKey: "eeff0011", Name: "ShortKey"}, // exactly 8 chars
+	}
+	pm := buildPrefixMap(nodes)
+
+	t.Run("short prefixes still work", func(t *testing.T) {
+		n := pm.resolve("aabb")
+		if n == nil || n.Name != "LongKey" {
+			t.Errorf("expected LongKey for short prefix, got %v", n)
+		}
+	})
+
+	t.Run("full pubkey exact match works", func(t *testing.T) {
+		n := pm.resolve("aabbccdd11223344")
+		if n == nil || n.Name != "LongKey" {
+			t.Errorf("expected LongKey for full key, got %v", n)
+		}
+	})
+
+	t.Run("intermediate prefix beyond cap returns nil", func(t *testing.T) {
+		// 10-char prefix — beyond maxPrefixLen but not full key
+		n := pm.resolve("aabbccdd11")
+		if n != nil {
+			t.Errorf("expected nil for intermediate prefix beyond cap, got %v", n.Name)
+		}
+	})
+
+	t.Run("short key within cap has all prefixes", func(t *testing.T) {
+		for l := 2; l <= 8; l++ {
+			pfx := "eeff0011"[:l]
+			n := pm.resolve(pfx)
+			if n == nil || n.Name != "ShortKey" {
+				t.Errorf("prefix %q: expected ShortKey, got %v", pfx, n)
+			}
+		}
+	})
+
+	t.Run("map size is capped", func(t *testing.T) {
+		// LongKey: 7 prefix entries (2..8) + 1 full key = 8
+		// ShortKey: 7 prefix entries (2..8), no full key entry (len == maxPrefixLen) = 7
+		// No overlapping prefixes between the two nodes → 8 + 7 = 15 unique map keys
+		if len(pm.m) != 15 {
+			t.Errorf("expected 15 map entries (8 for LongKey + 7 for ShortKey), got %d", len(pm.m))
+		}
+	})
+}
+
 // --- pathLen ---
 
 func TestPathLen(t *testing.T) {
@@ -1333,6 +1427,40 @@ func TestGetNodeLocations(t *testing.T) {
 	}
 }
 
+// --- GetNodeLocationsByKeys ---
+
+func TestGetNodeLocationsByKeys(t *testing.T) {
+	db := setupTestDB(t)
+	defer db.Close()
+	seedTestData(t, db)
+
+	// Query with a known key
+	pk := "aabbccdd11223344"
+	locs := db.GetNodeLocationsByKeys([]string{pk})
+	if len(locs) != 1 {
+		t.Errorf("expected 1 location, got %d", len(locs))
+	}
+	if entry, ok := locs[strings.ToLower(pk)]; ok {
+		if entry["lat"] == nil {
+			t.Error("expected non-nil lat")
+		}
+	} else {
+		t.Error("expected node location for test repeater")
+	}
+
+	// Query with no keys returns empty map
+	empty := db.GetNodeLocationsByKeys([]string{})
+	if len(empty) != 0 {
+		t.Errorf("expected 0 locations for empty keys, got %d", len(empty))
+	}
+
+	// Query with unknown key returns empty map
+	unknown := db.GetNodeLocationsByKeys([]string{"nonexistent"})
+	if len(unknown) != 0 {
+		t.Errorf("expected 0 locations for unknown key, got %d", len(unknown))
+	}
+}
+
 // --- Store edge cases ---
 
 func TestStoreQueryPacketsEdgeCases(t *testing.T) {
@@ -1906,6 +2034,48 @@ func TestTxToMap(t *testing.T) {
 	}
 }
 
+func TestTxToMapLazyObservations(t *testing.T) {
+	snr := 10.5
+	rssi := -90.0
+	tx := &StoreTx{
+		ID:   1,
+		Hash: "abc",
+		Observations: []*StoreObs{
+			{ID: 10, ObserverID: "obs1", ObserverName: "O1", SNR: &snr, RSSI: &rssi, Timestamp: "2025-01-01"},
+			{ID: 11, ObserverID: "obs2", ObserverName: "O2", SNR: &snr, RSSI: &rssi, Timestamp: "2025-01-02"},
+		},
+	}
+
+	// Without flag: no observations key
+	m := txToMap(tx)
+	if _, ok := m["observations"]; ok {
+		t.Error("txToMap without includeObservations should not include observations key")
+	}
+
+	// With false: no observations key
+	m = txToMap(tx, false)
+	if _, ok := m["observations"]; ok {
+		t.Error("txToMap(tx, false) should not include observations key")
+	}
+
+	// With true: observations included
+	m = txToMap(tx, true)
+	obs, ok := m["observations"]
+	if !ok {
+		t.Fatal("txToMap(tx, true) should include observations key")
+	}
+	obsList, ok := obs.([]map[string]interface{})
+	if !ok {
+		t.Fatal("observations should be []map[string]interface{}")
+	}
+	if len(obsList) != 2 {
+		t.Errorf("expected 2 observations, got %d", len(obsList))
+	}
+	if obsList[0]["observer_id"] != "obs1" {
+		t.Errorf("expected observer_id obs1, got %v", obsList[0]["observer_id"])
+	}
+}
+
 // --- filterTxSlice ---
 
 func TestFilterTxSlice(t *testing.T) {
@@ -2028,6 +2198,53 @@ func TestStoreGetAnalyticsHashSizes(t *testing.T) {
 	})
 }
 
+func TestHashSizesDistributionByRepeatersFiltersRole(t *testing.T) {
+	db := setupRichTestDB(t)
+	defer db.Close()
+	store := NewPacketStore(db, nil)
+	store.Load()
+
+	result := store.GetAnalyticsHashSizes("")
+
+	// distributionByRepeaters should only count repeater nodes.
+	// Rich test DB: aabbccdd11223344 = repeater (hash size 2), eeff00112233aabb = companion (hash size 3).
+	dbr, ok := result["distributionByRepeaters"].(map[string]int)
+	if !ok {
+		t.Fatal("expected distributionByRepeaters map")
+	}
+	// Only the repeater node should be counted.
+	if dbr["3"] != 0 {
+		t.Errorf("distributionByRepeaters[3] = %d, want 0 (companion should be excluded)", dbr["3"])
+	}
+	if dbr["2"] != 1 {
+		t.Errorf("distributionByRepeaters[2] = %d, want 1 (repeater)", dbr["2"])
+	}
+
+	// multiByteNodes should include role field for frontend filtering.
+	mbn, ok := result["multiByteNodes"].([]map[string]interface{})
+	if !ok {
+		t.Fatal("expected multiByteNodes slice")
+	}
+	for _, node := range mbn {
+		if _, hasRole := node["role"]; !hasRole {
+			t.Errorf("multiByteNodes entry missing 'role' field: %v", node)
+		}
+	}
+	// Verify companion is included in multiByteNodes (it's multi-byte) with correct role.
+	foundCompanion := false
+	for _, node := range mbn {
+		if node["pubkey"] == "eeff00112233aabb" {
+			foundCompanion = true
+			if node["role"] != "companion" {
+				t.Errorf("companion node role = %v, want 'companion'", node["role"])
+			}
+		}
+	}
+	if !foundCompanion {
+		t.Error("expected companion node in multiByteNodes (multi-byte adopters should include all roles)")
+	}
+}
+
 func TestStoreGetAnalyticsSubpaths(t *testing.T) {
 	db := setupRichTestDB(t)
 	defer db.Close()
@@ -2099,6 +2316,84 @@ func TestSubpathPrecomputedIndex(t *testing.T) {
 	}
 }
 
+func TestSubpathTxIndexPopulated(t *testing.T) {
+	db := setupRichTestDB(t)
+	defer db.Close()
+	store := NewPacketStore(db, nil)
+	store.Load()
+
+	// spTxIndex must be populated alongside spIndex
+	if len(store.spTxIndex) == 0 {
+		t.Fatal("expected spTxIndex to be populated after Load()")
+	}
+
+	// Every key in spIndex must also exist in spTxIndex with matching count
+	for key, count := range store.spIndex {
+		txs, ok := store.spTxIndex[key]
+		if !ok {
+			t.Errorf("spTxIndex missing key %q that exists in spIndex", key)
+			continue
+		}
+		if len(txs) != count {
+			t.Errorf("spTxIndex[%q] has %d txs, spIndex count is %d", key, len(txs), count)
+		}
+	}
+
+	// GetSubpathDetail should return correct match count via indexed lookup
+	detail := store.GetSubpathDetail([]string{"eeff", "0011"})
+	if detail == nil {
+		t.Fatal("expected non-nil detail for existing subpath")
+	}
+	matches, _ := detail["totalMatches"].(int)
+	if matches != 1 {
+		t.Errorf("totalMatches = %d, want 1", matches)
+	}
+
+	// Non-existent subpath should return 0 matches
+	detail2 := store.GetSubpathDetail([]string{"zzzz", "yyyy"})
+	if detail2 == nil {
+		t.Fatal("expected non-nil result even for non-existent subpath")
+	}
+	matches2, _ := detail2["totalMatches"].(int)
+	if matches2 != 0 {
+		t.Errorf("totalMatches for non-existent subpath = %d, want 0", matches2)
+	}
+}
+
+func TestSubpathDetailMixedCaseHops(t *testing.T) {
+	db := setupRichTestDB(t)
+	defer db.Close()
+	store := NewPacketStore(db, nil)
+	store.Load()
+
+	// Query with lowercase hops to establish baseline
+	lower := store.GetSubpathDetail([]string{"eeff", "0011"})
+	if lower == nil {
+		t.Fatal("expected non-nil detail for lowercase subpath")
+	}
+	lowerMatches, _ := lower["totalMatches"].(int)
+	if lowerMatches == 0 {
+		t.Fatal("expected >0 matches for lowercase subpath")
+	}
+
+	// Query with mixed-case hops — must return the same results (case-insensitive)
+	mixed := store.GetSubpathDetail([]string{"EEFF", "0011"})
+	if mixed == nil {
+		t.Fatal("expected non-nil detail for mixed-case subpath")
+	}
+	mixedMatches, _ := mixed["totalMatches"].(int)
+	if mixedMatches != lowerMatches {
+		t.Errorf("mixed-case totalMatches = %d, want %d (same as lowercase)", mixedMatches, lowerMatches)
+	}
+
+	// All-uppercase should also match
+	upper := store.GetSubpathDetail([]string{"EEFF", "0011"})
+	upperMatches, _ := upper["totalMatches"].(int)
+	if upperMatches != lowerMatches {
+		t.Errorf("uppercase totalMatches = %d, want %d", upperMatches, lowerMatches)
+	}
+}
+
 func TestStoreGetAnalyticsRFCacheHit(t *testing.T) {
 	db := setupRichTestDB(t)
 	defer db.Close()
@@ -3715,3 +4010,379 @@ func TestGetChannelMessagesAfterIngest(t *testing.T) {
 		t.Errorf("newest message should be 'brand new message', got %q", lastMsg["text"])
 	}
 }
+
+// --- resolveRegionObservers caching ---
+
+func TestResolveRegionObserversCaching(t *testing.T) {
+	db := setupTestDB(t)
+	defer db.Close()
+	seedTestData(t, db)
+
+	store := &PacketStore{db: db}
+
+	// First call should populate cache.
+	obs1 := store.resolveRegionObservers("SJC")
+	if obs1 == nil || len(obs1) == 0 {
+		t.Fatal("expected observer IDs for SJC on first call")
+	}
+
+	// Second call should return cached result (same pointer).
+	obs2 := store.resolveRegionObservers("SJC")
+	if len(obs2) != len(obs1) {
+		t.Errorf("cached result differs: got %d, want %d", len(obs2), len(obs1))
+	}
+
+	// Non-existent region should return nil even from cache.
+	obs3 := store.resolveRegionObservers("NONEXIST")
+	if obs3 != nil {
+		t.Errorf("expected nil for NONEXIST, got %v", obs3)
+	}
+
+	// Verify cache fields are set.
+	if store.regionObsCache == nil {
+		t.Error("regionObsCache should be non-nil after calls")
+	}
+	if store.regionObsCacheTime.IsZero() {
+		t.Error("regionObsCacheTime should be set")
+	}
+}
+
+func TestResolveRegionObserversCacheMissNewRegion(t *testing.T) {
+	db := setupTestDB(t)
+	defer db.Close()
+	seedTestData(t, db)
+
+	store := &PacketStore{db: db}
+
+	// Populate cache with SJC.
+	obs1 := store.resolveRegionObservers("SJC")
+	if obs1 == nil || len(obs1) == 0 {
+		t.Fatal("expected observer IDs for SJC on first call")
+	}
+
+	// Cache is now valid. Request a different region that exists in DB.
+	// Before the fix, this would return nil from the map lookup instead of
+	// fetching from DB, silently returning "no observers" for up to 30s.
+	obs2 := store.resolveRegionObservers("LAX")
+	// LAX may or may not have data in the test DB, but the key point is:
+	// a non-existent region should be fetched (not just nil-returned).
+	// Verify the region key was cached (even if empty).
+	store.regionObsMu.Lock()
+	_, cached := store.regionObsCache["LAX"]
+	store.regionObsMu.Unlock()
+	if !cached {
+		t.Error("LAX should be cached after resolveRegionObservers call, even if empty")
+	}
+	_ = obs2
+}
+
+func TestIndexByNodePreCheck(t *testing.T) {
+	store := &PacketStore{
+		byNode:     make(map[string][]*StoreTx),
+		nodeHashes: make(map[string]map[string]bool),
+	}
+
+	t.Run("indexes ADVERT with pubKey", func(t *testing.T) {
+		tx := &StoreTx{Hash: "h1", DecodedJSON: `{"pubKey":"AABBCC","type":"ADVERT"}`}
+		store.indexByNode(tx)
+		if len(store.byNode["AABBCC"]) != 1 {
+			t.Errorf("expected 1 entry for pubKey AABBCC, got %d", len(store.byNode["AABBCC"]))
+		}
+	})
+
+	t.Run("indexes destPubKey", func(t *testing.T) {
+		tx := &StoreTx{Hash: "h2", DecodedJSON: `{"destPubKey":"DDEEFF","type":"MSG"}`}
+		store.indexByNode(tx)
+		if len(store.byNode["DDEEFF"]) != 1 {
+			t.Errorf("expected 1 entry for destPubKey DDEEFF, got %d", len(store.byNode["DDEEFF"]))
+		}
+	})
+
+	t.Run("indexes srcPubKey", func(t *testing.T) {
+		tx := &StoreTx{Hash: "h2b", DecodedJSON: `{"srcPubKey":"112233","type":"TXT_MSG"}`}
+		store.indexByNode(tx)
+		if len(store.byNode["112233"]) != 1 {
+			t.Errorf("expected 1 entry for srcPubKey 112233, got %d", len(store.byNode["112233"]))
+		}
+	})
+
+	t.Run("skips channel message without pubKey", func(t *testing.T) {
+		beforeLen := len(store.byNode)
+		tx := &StoreTx{Hash: "h3", DecodedJSON: `{"type":"CHAN","channel":"#test","text":"hello"}`}
+		store.indexByNode(tx)
+		if len(store.byNode) != beforeLen {
+			t.Errorf("expected byNode unchanged for channel packet, got %d new entries", len(store.byNode)-beforeLen)
+		}
+	})
+
+	t.Run("skips empty DecodedJSON", func(t *testing.T) {
+		beforeLen := len(store.byNode)
+		tx := &StoreTx{Hash: "h4", DecodedJSON: ""}
+		store.indexByNode(tx)
+		if len(store.byNode) != beforeLen {
+			t.Error("expected byNode unchanged for empty DecodedJSON")
+		}
+	})
+
+	t.Run("deduplicates same hash", func(t *testing.T) {
+		tx := &StoreTx{Hash: "h1", DecodedJSON: `{"pubKey":"AABBCC","type":"ADVERT"}`}
+		store.indexByNode(tx) // second call for same hash
+		if len(store.byNode["AABBCC"]) != 1 {
+			t.Errorf("expected dedup to keep 1 entry, got %d", len(store.byNode["AABBCC"]))
+		}
+	})
+}
+
+// BenchmarkIndexByNode measures indexByNode performance with and without pubkey
+// fields to demonstrate the strings.Contains pre-check optimization.
+func BenchmarkIndexByNode(b *testing.B) {
+	// Payload WITHOUT any pubkey fields — should be skipped via pre-check
+	noPubkey := `{"type":1,"msgId":42,"sender":"node1","data":"hello world"}`
+	// Payload WITH a pubkey field — requires JSON parse
+	withPubkey := `{"type":1,"msgId":42,"pubKey":"AABB","sender":"node1","data":"hello world"}`
+
+	b.Run("no_pubkey_skip", func(b *testing.B) {
+		store := &PacketStore{
+			byNode:     make(map[string][]*StoreTx),
+			nodeHashes: make(map[string]map[string]bool),
+		}
+		b.ResetTimer()
+		for i := 0; i < b.N; i++ {
+			tx := &StoreTx{
+				Hash:        fmt.Sprintf("hash-%d", i),
+				DecodedJSON: noPubkey,
+			}
+			store.indexByNode(tx)
+		}
+	})
+
+	b.Run("with_pubkey_parse", func(b *testing.B) {
+		store := &PacketStore{
+			byNode:     make(map[string][]*StoreTx),
+			nodeHashes: make(map[string]map[string]bool),
+		}
+		b.ResetTimer()
+		for i := 0; i < b.N; i++ {
+			tx := &StoreTx{
+				Hash:        fmt.Sprintf("hash-%d", i),
+				DecodedJSON: withPubkey,
+			}
+			store.indexByNode(tx)
+		}
+	})
+}
+
+// --- Multi-observer comma-separated filter tests ---
+
+func TestTransmissionsForObserverMultiCSV(t *testing.T) {
+	db := setupTestDB(t)
+	defer db.Close()
+	seedTestData(t, db)
+	store := NewPacketStore(db, nil)
+	store.Load()
+
+	t.Run("comma-separated returns union via index", func(t *testing.T) {
+		result := store.transmissionsForObserver("obs1,obs2", nil)
+		if len(result) == 0 {
+			t.Fatal("expected results for obs1,obs2")
+		}
+		// obs1 has transmissions 1,2,3; obs2 has transmission 1
+		// Union should include all unique transmissions
+		obs1Only := store.transmissionsForObserver("obs1", nil)
+		obs2Only := store.transmissionsForObserver("obs2", nil)
+		if len(result) < len(obs1Only) || len(result) < len(obs2Only) {
+			t.Errorf("union (%d) should be >= each individual set (obs1=%d, obs2=%d)",
+				len(result), len(obs1Only), len(obs2Only))
+		}
+	})
+
+	t.Run("comma-separated with spaces via index", func(t *testing.T) {
+		result := store.transmissionsForObserver("obs1, obs2", nil)
+		if len(result) == 0 {
+			t.Fatal("expected results for 'obs1, obs2' (with space)")
+		}
+		noSpace := store.transmissionsForObserver("obs1,obs2", nil)
+		if len(result) != len(noSpace) {
+			t.Errorf("with-space (%d) should equal no-space (%d)", len(result), len(noSpace))
+		}
+	})
+
+	t.Run("comma-separated returns union via filter path", func(t *testing.T) {
+		allTx := store.packets
+		result := store.transmissionsForObserver("obs1,obs2", allTx)
+		if len(result) == 0 {
+			t.Fatal("expected results for obs1,obs2 via filter path")
+		}
+	})
+
+	t.Run("comma-separated with spaces via filter path", func(t *testing.T) {
+		allTx := store.packets
+		withSpace := store.transmissionsForObserver("obs1, obs2", allTx)
+		noSpace := store.transmissionsForObserver("obs1,obs2", allTx)
+		if len(withSpace) != len(noSpace) {
+			t.Errorf("filter path: with-space (%d) should equal no-space (%d)", len(withSpace), len(noSpace))
+		}
+	})
+}
+
+func TestBuildTransmissionWhereMultiObserver(t *testing.T) {
+	db := setupTestDB(t)
+	defer db.Close()
+	seedTestData(t, db)
+
+	t.Run("comma-separated produces IN clause", func(t *testing.T) {
+		q := PacketQuery{Observer: "obs1,obs2"}
+		where, args := db.buildTransmissionWhere(q)
+		if len(where) != 1 {
+			t.Fatalf("expected 1 WHERE clause, got %d", len(where))
+		}
+		clause := where[0]
+		if !strings.Contains(clause, "IN (?,?)") {
+			t.Errorf("expected IN (?,?) in clause, got: %s", clause)
+		}
+		if len(args) != 2 {
+			t.Fatalf("expected 2 args, got %d", len(args))
+		}
+		if args[0] != "obs1" || args[1] != "obs2" {
+			t.Errorf("expected [obs1, obs2], got %v", args)
+		}
+	})
+
+	t.Run("comma-separated with spaces trims IDs", func(t *testing.T) {
+		q := PacketQuery{Observer: "obs1, obs2"}
+		_, args := db.buildTransmissionWhere(q)
+		if len(args) != 2 {
+			t.Fatalf("expected 2 args, got %d", len(args))
+		}
+		if args[0] != "obs1" || args[1] != "obs2" {
+			t.Errorf("expected trimmed [obs1, obs2], got %v", args)
+		}
+	})
+
+	t.Run("single observer still works", func(t *testing.T) {
+		q := PacketQuery{Observer: "obs1"}
+		where, args := db.buildTransmissionWhere(q)
+		if len(where) != 1 {
+			t.Fatalf("expected 1 WHERE clause, got %d", len(where))
+		}
+		if !strings.Contains(where[0], "IN (?)") {
+			t.Errorf("expected IN (?) for single observer, got: %s", where[0])
+		}
+		if len(args) != 1 || args[0] != "obs1" {
+			t.Errorf("expected [obs1], got %v", args)
+		}
+	})
+}
+
+// --- Distance index incremental update (#365, replaces debounce #557) ---
+
+func TestDistanceIncrementalUpdate(t *testing.T) {
+	db := setupTestDB(t)
+	defer db.Close()
+	seedTestData(t, db)
+	store := NewPacketStore(db, nil)
+	store.Load()
+
+	// Record initial distance index size.
+	initialHops := len(store.distHops)
+	initialPaths := len(store.distPaths)
+
+	// Insert a new observation with a different path to trigger an incremental update.
+	maxObsID := db.GetMaxObservationID()
+	db.conn.Exec(`INSERT INTO observations (transmission_id, observer_idx, snr, rssi, path_json, timestamp)
+		VALUES (1, 2, 5.0, -100, '["xx","yy","zz"]', ?)`, time.Now().Unix())
+
+	store.IngestNewObservations(maxObsID, 500)
+
+	// Distance index should have been updated incrementally (sizes may differ
+	// if the new path resolves differently, but should not panic or corrupt).
+	_ = len(store.distHops)
+	_ = len(store.distPaths)
+
+	// Insert another observation with yet another path.
+	maxObsID = db.GetMaxObservationID()
+	db.conn.Exec(`INSERT INTO observations (transmission_id, observer_idx, snr, rssi, path_json, timestamp)
+		VALUES (1, 2, 7.0, -95, '["aa","bb","cc","dd"]', ?)`, time.Now().Unix())
+
+	store.IngestNewObservations(maxObsID, 500)
+
+	// Verify the index is still coherent (no duplicates for the same tx).
+	txSeen := make(map[int]int)
+	for _, r := range store.distPaths {
+		if r.tx != nil {
+			txSeen[r.tx.ID]++
+		}
+	}
+	for txID, count := range txSeen {
+		if count > 1 {
+			t.Errorf("distPaths has %d entries for tx %d (expected at most 1)", count, txID)
+		}
+	}
+
+	t.Logf("Distance index: %d→%d hops, %d→%d paths (incremental)",
+		initialHops, len(store.distHops), initialPaths, len(store.distPaths))
+}
+
+func TestHandleBatchObservations(t *testing.T) {
+	_, router := setupNoStoreServer(t)
+
+	t.Run("empty hashes returns empty results", func(t *testing.T) {
+		body := strings.NewReader(`{"hashes":[]}`)
+		req := httptest.NewRequest("POST", "/api/packets/observations", body)
+		req.Header.Set("Content-Type", "application/json")
+		w := httptest.NewRecorder()
+		router.ServeHTTP(w, req)
+		if w.Code != 200 {
+			t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
+		}
+		var resp map[string]interface{}
+		json.Unmarshal(w.Body.Bytes(), &resp)
+		results, ok := resp["results"].(map[string]interface{})
+		if !ok || len(results) != 0 {
+			t.Fatalf("expected empty results map, got %v", resp)
+		}
+	})
+
+	t.Run("invalid JSON returns 400", func(t *testing.T) {
+		body := strings.NewReader(`not json`)
+		req := httptest.NewRequest("POST", "/api/packets/observations", body)
+		req.Header.Set("Content-Type", "application/json")
+		w := httptest.NewRecorder()
+		router.ServeHTTP(w, req)
+		if w.Code != 400 {
+			t.Fatalf("expected 400, got %d", w.Code)
+		}
+	})
+
+	t.Run("too many hashes returns 400", func(t *testing.T) {
+		hashes := make([]string, 201)
+		for i := range hashes {
+			hashes[i] = fmt.Sprintf("hash%d", i)
+		}
+		data, _ := json.Marshal(map[string][]string{"hashes": hashes})
+		req := httptest.NewRequest("POST", "/api/packets/observations", bytes.NewReader(data))
+		req.Header.Set("Content-Type", "application/json")
+		w := httptest.NewRecorder()
+		router.ServeHTTP(w, req)
+		if w.Code != 400 {
+			t.Fatalf("expected 400, got %d", w.Code)
+		}
+	})
+
+	t.Run("valid hashes with no store returns empty results", func(t *testing.T) {
+		body := strings.NewReader(`{"hashes":["abc123","def456"]}`)
+		req := httptest.NewRequest("POST", "/api/packets/observations", body)
+		req.Header.Set("Content-Type", "application/json")
+		w := httptest.NewRecorder()
+		router.ServeHTTP(w, req)
+		if w.Code != 200 {
+			t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
+		}
+		var resp map[string]interface{}
+		json.Unmarshal(w.Body.Bytes(), &resp)
+		_, ok := resp["results"].(map[string]interface{})
+		if !ok {
+			t.Fatalf("expected results map, got %v", resp)
+		}
+	})
+}

cmd/server/db.go

@@ -15,9 +15,10 @@ import (
 
 // DB wraps a read-only connection to the MeshCore SQLite database.
 type DB struct {
-	conn *sql.DB
-	path string // filesystem path to the database file
-	isV3 bool   // v3 schema: observer_idx in observations (vs observer_id in v2)
+	conn             *sql.DB
+	path             string // filesystem path to the database file
+	isV3             bool   // v3 schema: observer_idx in observations (vs observer_id in v2)
+	hasResolvedPath  bool   // observations table has resolved_path column
 }
 
 // OpenDB opens a read-only SQLite connection with WAL mode.
@@ -61,9 +62,13 @@ func (db *DB) detectSchema() {
 		var colType sql.NullString
 		var notNull, pk int
 		var dflt sql.NullString
-		if rows.Scan(&cid, &colName, &colType, &notNull, &dflt, &pk) == nil && colName == "observer_idx" {
-			db.isV3 = true
-			return
+		if rows.Scan(&cid, &colName, &colType, &notNull, &dflt, &pk) == nil {
+			if colName == "observer_idx" {
+				db.isV3 = true
+			}
+			if colName == "resolved_path" {
+				db.hasResolvedPath = true
+			}
 		}
 	}
 }
@@ -372,7 +377,8 @@ type PacketQuery struct {
 	Until    string
 	Region   string
 	Node     string
-	Order    string // ASC or DESC
+	Order               string // ASC or DESC
+	ExpandObservations  bool   // when true, include observation sub-maps in txToMap output
 }
 
 // PacketResult wraps paginated packet list.
@@ -608,12 +614,17 @@ func (db *DB) buildTransmissionWhere(q PacketQuery) ([]string, []interface{}) {
 		args = append(args, "%"+pk+"%")
 	}
 	if q.Observer != "" {
+		ids := strings.Split(q.Observer, ",")
+		placeholders := strings.Repeat("?,", len(ids))
+		placeholders = placeholders[:len(placeholders)-1]
 		if db.isV3 {
-			where = append(where, "EXISTS (SELECT 1 FROM observations oi JOIN observers obi ON obi.rowid = oi.observer_idx WHERE oi.transmission_id = t.id AND obi.id = ?)")
+			where = append(where, "EXISTS (SELECT 1 FROM observations oi JOIN observers obi ON obi.rowid = oi.observer_idx WHERE oi.transmission_id = t.id AND obi.id IN ("+placeholders+"))")
 		} else {
-			where = append(where, "EXISTS (SELECT 1 FROM observations oi WHERE oi.transmission_id = t.id AND oi.observer_id = ?)")
+			where = append(where, "EXISTS (SELECT 1 FROM observations oi WHERE oi.transmission_id = t.id AND oi.observer_id IN ("+placeholders+"))")
+		}
+		for _, id := range ids {
+			args = append(args, strings.TrimSpace(id))
 		}
-		args = append(args, q.Observer)
 	}
 	if q.Region != "" {
 		if db.isV3 {
@@ -698,6 +709,32 @@ func (db *DB) GetNodes(limit, offset int, role, search, before, lastHeard, sortB
 		}
 	}
 
+	if region != "" {
+		codes := normalizeRegionCodes(region)
+		if len(codes) > 0 {
+			placeholders := make([]string, len(codes))
+			regionArgs := make([]interface{}, len(codes))
+			for i, c := range codes {
+				placeholders[i] = "?"
+				regionArgs[i] = c
+			}
+			joinCond := "obs.rowid = o.observer_idx"
+			if !db.isV3 {
+				joinCond = "obs.id = o.observer_id"
+			}
+			subq := fmt.Sprintf(`public_key IN (
+				SELECT DISTINCT JSON_EXTRACT(t.decoded_json, '$.pubKey')
+				FROM transmissions t
+				JOIN observations o ON o.transmission_id = t.id
+				JOIN observers obs ON %s
+				WHERE t.payload_type = 4
+				AND UPPER(TRIM(obs.iata)) IN (%s)
+			)`, joinCond, strings.Join(placeholders, ","))
+			where = append(where, subq)
+			args = append(args, regionArgs...)
+		}
+	}
+
 	w := ""
 	if len(where) > 0 {
 		w = "WHERE " + strings.Join(where, " AND ")
@@ -1461,6 +1498,39 @@ func (db *DB) GetNodeLocations() map[string]map[string]interface{} {
 	return result
 }
 
+// GetNodeLocationsByKeys returns location data only for the given public keys.
+// This avoids fetching ALL nodes when only a few keys need to be matched.
+func (db *DB) GetNodeLocationsByKeys(keys []string) map[string]map[string]interface{} {
+	result := make(map[string]map[string]interface{})
+	if len(keys) == 0 {
+		return result
+	}
+	placeholders := make([]string, len(keys))
+	args := make([]interface{}, len(keys))
+	for i, k := range keys {
+		placeholders[i] = "?"
+		args[i] = strings.ToLower(k)
+	}
+	query := "SELECT public_key, lat, lon, role FROM nodes WHERE LOWER(public_key) IN (" + strings.Join(placeholders, ",") + ")"
+	rows, err := db.conn.Query(query, args...)
+	if err != nil {
+		return result
+	}
+	defer rows.Close()
+	for rows.Next() {
+		var pk string
+		var role sql.NullString
+		var lat, lon sql.NullFloat64
+		rows.Scan(&pk, &lat, &lon, &role)
+		result[strings.ToLower(pk)] = map[string]interface{}{
+			"lat":  nullFloat(lat),
+			"lon":  nullFloat(lon),
+			"role": nullStr(role),
+		}
+	}
+	return result
+}
+
 // QueryMultiNodePackets returns transmissions referencing any of the given pubkeys.
 func (db *DB) QueryMultiNodePackets(pubkeys []string, limit, offset int, order, since, until string) (*PacketResult, error) {
 	if len(pubkeys) == 0 {
@@ -1664,3 +1734,341 @@ func (db *DB) PruneOldPackets(days int) (int64, error) {
 	n, _ := res.RowsAffected()
 	return n, tx.Commit()
 }
+
+// MetricsSample represents a single row from observer_metrics with computed deltas.
+type MetricsSample struct {
+	Timestamp     string   `json:"timestamp"`
+	NoiseFloor    *float64 `json:"noise_floor"`
+	TxAirSecs     *int     `json:"tx_air_secs,omitempty"`
+	RxAirSecs     *int     `json:"rx_air_secs,omitempty"`
+	RecvErrors    *int     `json:"recv_errors,omitempty"`
+	BatteryMv     *int     `json:"battery_mv"`
+	PacketsSent   *int     `json:"packets_sent,omitempty"`
+	PacketsRecv   *int     `json:"packets_recv,omitempty"`
+	TxAirtimePct  *float64 `json:"tx_airtime_pct"`
+	RxAirtimePct  *float64 `json:"rx_airtime_pct"`
+	RecvErrorRate *float64 `json:"recv_error_rate"`
+	IsReboot      bool     `json:"is_reboot_sample,omitempty"`
+}
+
+// rawMetricsSample is the raw DB row before delta computation.
+type rawMetricsSample struct {
+	Timestamp   string
+	NoiseFloor  *float64
+	TxAirSecs   *int
+	RxAirSecs   *int
+	RecvErrors  *int
+	BatteryMv   *int
+	PacketsSent *int
+	PacketsRecv *int
+}
+
+// GetObserverMetrics returns time-series metrics with server-side delta computation.
+// resolution: "5m" (raw), "1h", "1d"
+// sampleIntervalSec: expected interval between samples (default 300)
+func (db *DB) GetObserverMetrics(observerID, since, until, resolution string, sampleIntervalSec int) ([]MetricsSample, []string, error) {
+	if sampleIntervalSec <= 0 {
+		sampleIntervalSec = 300
+	}
+
+	// Build query based on resolution
+	var query string
+	args := []interface{}{observerID}
+
+	// Determine the effective bucket size for gap threshold scaling.
+	// For raw data (5m), use sampleIntervalSec. For aggregated resolutions,
+	// use the bucket duration so consecutive buckets aren't treated as gaps.
+	bucketSizeSec := sampleIntervalSec
+	switch resolution {
+	case "1h":
+		bucketSizeSec = 3600
+		// Use LAST value per bucket (latest timestamp) instead of MAX to preserve
+		// reboot semantics: if a device reboots mid-bucket, the last sample is the
+		// post-reboot baseline, not the pre-reboot high-water mark.
+		query = `SELECT ts, noise_floor, tx_air_secs, rx_air_secs, recv_errors, battery_mv, packets_sent, packets_recv FROM (
+			SELECT
+				strftime('%Y-%m-%dT%H:00:00Z', timestamp) as ts,
+				noise_floor, tx_air_secs, rx_air_secs, recv_errors, battery_mv, packets_sent, packets_recv,
+				ROW_NUMBER() OVER (PARTITION BY observer_id, strftime('%Y-%m-%dT%H:00:00Z', timestamp) ORDER BY timestamp DESC) as rn
+			FROM observer_metrics WHERE observer_id = ?`
+	case "1d":
+		bucketSizeSec = 86400
+		query = `SELECT ts, noise_floor, tx_air_secs, rx_air_secs, recv_errors, battery_mv, packets_sent, packets_recv FROM (
+			SELECT
+				strftime('%Y-%m-%dT00:00:00Z', timestamp) as ts,
+				noise_floor, tx_air_secs, rx_air_secs, recv_errors, battery_mv, packets_sent, packets_recv,
+				ROW_NUMBER() OVER (PARTITION BY observer_id, strftime('%Y-%m-%dT00:00:00Z', timestamp) ORDER BY timestamp DESC) as rn
+			FROM observer_metrics WHERE observer_id = ?`
+	default: // "5m" or raw
+		query = `SELECT timestamp, noise_floor, tx_air_secs, rx_air_secs, recv_errors, battery_mv, packets_sent, packets_recv
+			FROM observer_metrics WHERE observer_id = ?`
+	}
+
+	if since != "" {
+		query += " AND timestamp >= ?"
+		args = append(args, since)
+	}
+	if until != "" {
+		query += " AND timestamp <= ?"
+		args = append(args, until)
+	}
+
+	switch resolution {
+	case "1h", "1d":
+		query += ") WHERE rn = 1 ORDER BY ts ASC"
+	default:
+		query += " ORDER BY timestamp ASC"
+	}
+
+	rows, err := db.conn.Query(query, args...)
+	if err != nil {
+		return nil, nil, err
+	}
+	defer rows.Close()
+
+	var raw []rawMetricsSample
+	for rows.Next() {
+		var s rawMetricsSample
+		if err := rows.Scan(&s.Timestamp, &s.NoiseFloor, &s.TxAirSecs, &s.RxAirSecs, &s.RecvErrors, &s.BatteryMv, &s.PacketsSent, &s.PacketsRecv); err != nil {
+			return nil, nil, err
+		}
+		raw = append(raw, s)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, nil, err
+	}
+
+	// Compute deltas between consecutive samples.
+	// bucketSizeSec determines gap threshold: for raw data it's sampleIntervalSec,
+	// for aggregated resolutions it's the bucket duration (3600 for 1h, 86400 for 1d).
+	return computeDeltas(raw, bucketSizeSec)
+}
+
+// computeDeltas computes per-interval rates from cumulative counters.
+// Handles reboots (counter reset) and gaps (missing samples).
+// bucketSizeSec is the expected interval between consecutive points
+// (sampleInterval for raw data, bucket duration for aggregated resolutions).
+func computeDeltas(raw []rawMetricsSample, bucketSizeSec int) ([]MetricsSample, []string, error) {
+	if len(raw) == 0 {
+		return nil, nil, nil
+	}
+
+	gapThreshold := float64(bucketSizeSec) * 2.0
+	result := make([]MetricsSample, 0, len(raw))
+	var reboots []string
+
+	for i, cur := range raw {
+		s := MetricsSample{
+			Timestamp:  cur.Timestamp,
+			NoiseFloor: cur.NoiseFloor,
+			BatteryMv:  cur.BatteryMv,
+		}
+
+		if i == 0 {
+			// First sample: no delta possible
+			result = append(result, s)
+			continue
+		}
+
+		prev := raw[i-1]
+
+		// Check for gap
+		curT, err1 := time.Parse(time.RFC3339, cur.Timestamp)
+		prevT, err2 := time.Parse(time.RFC3339, prev.Timestamp)
+		if err1 != nil || err2 != nil {
+			result = append(result, s)
+			continue
+		}
+		intervalSecs := curT.Sub(prevT).Seconds()
+		if intervalSecs > gapThreshold {
+			// Gap detected: insert null deltas (don't interpolate)
+			result = append(result, s)
+			continue
+		}
+		if intervalSecs <= 0 {
+			result = append(result, s)
+			continue
+		}
+
+		// Detect reboot: any cumulative counter decreased
+		isReboot := false
+		if cur.TxAirSecs != nil && prev.TxAirSecs != nil && *cur.TxAirSecs < *prev.TxAirSecs {
+			isReboot = true
+		}
+		if cur.RxAirSecs != nil && prev.RxAirSecs != nil && *cur.RxAirSecs < *prev.RxAirSecs {
+			isReboot = true
+		}
+		if cur.RecvErrors != nil && prev.RecvErrors != nil && *cur.RecvErrors < *prev.RecvErrors {
+			isReboot = true
+		}
+		if cur.PacketsSent != nil && prev.PacketsSent != nil && *cur.PacketsSent < *prev.PacketsSent {
+			isReboot = true
+		}
+		if cur.PacketsRecv != nil && prev.PacketsRecv != nil && *cur.PacketsRecv < *prev.PacketsRecv {
+			isReboot = true
+		}
+
+		if isReboot {
+			s.IsReboot = true
+			reboots = append(reboots, cur.Timestamp)
+			// Skip delta computation for reboot samples — use as new baseline
+			result = append(result, s)
+			continue
+		}
+
+		// Compute TX airtime percentage
+		if cur.TxAirSecs != nil && prev.TxAirSecs != nil {
+			delta := float64(*cur.TxAirSecs - *prev.TxAirSecs)
+			pct := (delta / intervalSecs) * 100.0
+			if pct < 0 {
+				pct = 0
+			}
+			if pct > 100 {
+				pct = 100
+			}
+			result_pct := math.Round(pct*100) / 100
+			s.TxAirtimePct = &result_pct
+		}
+
+		// Compute RX airtime percentage
+		if cur.RxAirSecs != nil && prev.RxAirSecs != nil {
+			delta := float64(*cur.RxAirSecs - *prev.RxAirSecs)
+			pct := (delta / intervalSecs) * 100.0
+			if pct < 0 {
+				pct = 0
+			}
+			if pct > 100 {
+				pct = 100
+			}
+			result_pct := math.Round(pct*100) / 100
+			s.RxAirtimePct = &result_pct
+		}
+
+		// Compute recv error rate
+		if cur.RecvErrors != nil && prev.RecvErrors != nil &&
+			cur.PacketsRecv != nil && prev.PacketsRecv != nil {
+			deltaErrors := float64(*cur.RecvErrors - *prev.RecvErrors)
+			deltaRecv := float64(*cur.PacketsRecv - *prev.PacketsRecv)
+			total := deltaRecv + deltaErrors
+			if total > 0 {
+				rate := (deltaErrors / total) * 100.0
+				rate = math.Round(rate*100) / 100
+				s.RecvErrorRate = &rate
+			}
+		}
+
+		result = append(result, s)
+	}
+
+	return result, reboots, nil
+}
+
+// MetricsSummaryRow holds summary data for one observer.
+type MetricsSummaryRow struct {
+	ObserverID    string     `json:"observer_id"`
+	ObserverName  *string    `json:"observer_name"`
+	IATA          string     `json:"iata,omitempty"`
+	CurrentNF     *float64   `json:"current_noise_floor"`
+	AvgNF         *float64   `json:"avg_noise_floor_24h"`
+	MaxNF         *float64   `json:"max_noise_floor_24h"`
+	CurrentBattMv *int       `json:"battery_mv"`
+	SampleCount   int        `json:"sample_count"`
+	Sparkline     []*float64 `json:"sparkline"`
+}
+
+// GetMetricsSummary returns a fleet summary of observer metrics within a time window.
+// Uses a CTE with ROW_NUMBER to get latest values in a single pass (no correlated subqueries).
+// Also returns sparkline data (noise_floor time series) per observer.
+func (db *DB) GetMetricsSummary(since string) ([]MetricsSummaryRow, error) {
+	query := `
+		WITH ranked AS (
+			SELECT observer_id, noise_floor, battery_mv,
+				ROW_NUMBER() OVER (PARTITION BY observer_id ORDER BY timestamp DESC) as rn
+			FROM observer_metrics
+			WHERE timestamp >= ?
+		)
+		SELECT m.observer_id, o.name, COALESCE(o.iata, '') as iata,
+			r.noise_floor as current_nf,
+			AVG(m.noise_floor) as avg_nf,
+			MAX(m.noise_floor) as max_nf,
+			r.battery_mv as current_batt,
+			COUNT(*) as sample_count
+		FROM observer_metrics m
+		LEFT JOIN observers o ON o.id = m.observer_id
+		LEFT JOIN ranked r ON r.observer_id = m.observer_id AND r.rn = 1
+		WHERE m.timestamp >= ?
+		GROUP BY m.observer_id
+		ORDER BY max_nf DESC
+	`
+	rows, err := db.conn.Query(query, since, since)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var result []MetricsSummaryRow
+	for rows.Next() {
+		var s MetricsSummaryRow
+		if err := rows.Scan(&s.ObserverID, &s.ObserverName, &s.IATA, &s.CurrentNF, &s.AvgNF, &s.MaxNF, &s.CurrentBattMv, &s.SampleCount); err != nil {
+			return nil, err
+		}
+		result = append(result, s)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+
+	// Fetch sparkline data (noise_floor series) for all observers in one query
+	if len(result) > 0 {
+		sparkQuery := `SELECT observer_id, noise_floor FROM observer_metrics
+			WHERE timestamp >= ? ORDER BY observer_id, timestamp ASC`
+		sparkRows, err := db.conn.Query(sparkQuery, since)
+		if err != nil {
+			return nil, err
+		}
+		defer sparkRows.Close()
+
+		sparkMap := make(map[string][]*float64)
+		for sparkRows.Next() {
+			var oid string
+			var nf *float64
+			if err := sparkRows.Scan(&oid, &nf); err != nil {
+				return nil, err
+			}
+			sparkMap[oid] = append(sparkMap[oid], nf)
+		}
+		if err := sparkRows.Err(); err != nil {
+			return nil, err
+		}
+
+		for i := range result {
+			if s, ok := sparkMap[result[i].ObserverID]; ok {
+				result[i].Sparkline = s
+			}
+		}
+	}
+
+	return result, nil
+}
+
+// PruneOldMetrics deletes observer_metrics rows older than retentionDays.
+func (db *DB) PruneOldMetrics(retentionDays int) (int64, error) {
+	dsn := fmt.Sprintf("file:%s?_journal_mode=WAL&_busy_timeout=10000", db.path)
+	rw, err := sql.Open("sqlite", dsn)
+	if err != nil {
+		return 0, err
+	}
+	rw.SetMaxOpenConns(1)
+	defer rw.Close()
+
+	cutoff := time.Now().UTC().AddDate(0, 0, -retentionDays).Format(time.RFC3339)
+	res, err := rw.Exec(`DELETE FROM observer_metrics WHERE timestamp < ?`, cutoff)
+	if err != nil {
+		return 0, err
+	}
+	n, _ := res.RowsAffected()
+	if n > 0 {
+		log.Printf("[metrics] Pruned %d observer_metrics rows older than %d days", n, retentionDays)
+	}
+	return n, nil
+}

cmd/server/db_test.go

@@ -72,15 +72,31 @@ func setupTestDB(t *testing.T) *DB {
 			rssi REAL,
 			score INTEGER,
 			path_json TEXT,
-			timestamp INTEGER NOT NULL
+			timestamp INTEGER NOT NULL,
+			resolved_path TEXT
 		);
 
+		CREATE TABLE IF NOT EXISTS observer_metrics (
+			observer_id TEXT NOT NULL,
+			timestamp TEXT NOT NULL,
+			noise_floor REAL,
+			tx_air_secs INTEGER,
+			rx_air_secs INTEGER,
+			recv_errors INTEGER,
+			battery_mv INTEGER,
+			packets_sent INTEGER,
+			packets_recv INTEGER,
+			PRIMARY KEY (observer_id, timestamp)
+		);
+
+		CREATE INDEX IF NOT EXISTS idx_observer_metrics_timestamp ON observer_metrics(timestamp);
+
 	`
 	if _, err := conn.Exec(schema); err != nil {
 		t.Fatal(err)
 	}
 
-	return &DB{conn: conn, isV3: true}
+	return &DB{conn: conn, isV3: true, hasResolvedPath: true}
 }
 
 func seedTestData(t *testing.T, db *DB) {
@@ -117,14 +133,15 @@ func seedTestData(t *testing.T, db *DB) {
 		VALUES ('AA1F', 'def456abc1230099', ?, 1, 4, '{"pubKey":"aabbccdd11223344","name":"TestRepeater","type":"ADVERT","timestamp":1700000100,"timestampISO":"2023-11-14T22:14:40.000Z","signature":"fedcba","flags":{"isRepeater":true},"lat":37.5,"lon":-122.0}')`, yesterday)
 
 	// Seed observations (use unix timestamps)
-	db.conn.Exec(`INSERT INTO observations (transmission_id, observer_idx, snr, rssi, path_json, timestamp)
-		VALUES (1, 1, 12.5, -90, '["aa","bb"]', ?)`, recentEpoch)
-	db.conn.Exec(`INSERT INTO observations (transmission_id, observer_idx, snr, rssi, path_json, timestamp)
-		VALUES (1, 2, 8.0, -95, '["aa"]', ?)`, recentEpoch-100)
+	// resolved_path contains full pubkeys parallel to path_json hops
+	db.conn.Exec(`INSERT INTO observations (transmission_id, observer_idx, snr, rssi, path_json, timestamp, resolved_path)
+		VALUES (1, 1, 12.5, -90, '["aa","bb"]', ?, '["aabbccdd11223344","eeff00112233aabb"]')`, recentEpoch)
+	db.conn.Exec(`INSERT INTO observations (transmission_id, observer_idx, snr, rssi, path_json, timestamp, resolved_path)
+		VALUES (1, 2, 8.0, -95, '["aa"]', ?, '["aabbccdd11223344"]')`, recentEpoch-100)
 	db.conn.Exec(`INSERT INTO observations (transmission_id, observer_idx, snr, rssi, path_json, timestamp)
 		VALUES (2, 1, 15.0, -85, '[]', ?)`, yesterdayEpoch)
-	db.conn.Exec(`INSERT INTO observations (transmission_id, observer_idx, snr, rssi, path_json, timestamp)
-		VALUES (3, 1, 10.0, -92, '["cc"]', ?)`, yesterdayEpoch)
+	db.conn.Exec(`INSERT INTO observations (transmission_id, observer_idx, snr, rssi, path_json, timestamp, resolved_path)
+		VALUES (3, 1, 10.0, -92, '["cc"]', ?, '["1122334455667788"]')`, yesterdayEpoch)
 }
 
 func TestGetStats(t *testing.T) {
@@ -1012,6 +1029,168 @@ func TestGetNodesFiltering(t *testing.T) {
 			t.Errorf("expected 1 node with offset, got %d", len(nodes))
 		}
 	})
+
+	t.Run("region filter SJC", func(t *testing.T) {
+		nodes, total, _, err := db.GetNodes(50, 0, "", "", "", "", "", "SJC")
+		if err != nil {
+			t.Fatal(err)
+		}
+		if total != 1 {
+			t.Errorf("expected 1 node for SJC region, got %d", total)
+		}
+		if len(nodes) != 1 {
+			t.Fatalf("expected 1 node, got %d", len(nodes))
+		}
+		if nodes[0]["public_key"] != "aabbccdd11223344" {
+			t.Errorf("expected TestRepeater, got %v", nodes[0]["public_key"])
+		}
+	})
+
+	t.Run("region filter SFO", func(t *testing.T) {
+		_, total, _, err := db.GetNodes(50, 0, "", "", "", "", "", "SFO")
+		if err != nil {
+			t.Fatal(err)
+		}
+		if total != 1 {
+			t.Errorf("expected 1 node for SFO region, got %d", total)
+		}
+	})
+
+	t.Run("region filter multi", func(t *testing.T) {
+		_, total, _, err := db.GetNodes(50, 0, "", "", "", "", "", "SJC,SFO")
+		if err != nil {
+			t.Fatal(err)
+		}
+		if total != 1 {
+			t.Errorf("expected 1 node for SJC,SFO region, got %d", total)
+		}
+	})
+
+	t.Run("region filter unknown", func(t *testing.T) {
+		_, total, _, err := db.GetNodes(50, 0, "", "", "", "", "", "AMS")
+		if err != nil {
+			t.Fatal(err)
+		}
+		if total != 0 {
+			t.Errorf("expected 0 nodes for unknown region, got %d", total)
+		}
+	})
+}
+
+// setupTestDBV2 creates an in-memory SQLite database with the v2 schema
+// where observations use observer_id TEXT instead of observer_idx INTEGER.
+func setupTestDBV2(t *testing.T) *DB {
+	t.Helper()
+	conn, err := sql.Open("sqlite", ":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	conn.SetMaxOpenConns(1)
+
+	schema := `
+		CREATE TABLE nodes (
+			public_key TEXT PRIMARY KEY,
+			name TEXT,
+			role TEXT,
+			lat REAL,
+			lon REAL,
+			last_seen TEXT,
+			first_seen TEXT,
+			advert_count INTEGER DEFAULT 0,
+			battery_mv INTEGER,
+			temperature_c REAL
+		);
+
+		CREATE TABLE observers (
+			id TEXT PRIMARY KEY,
+			name TEXT,
+			iata TEXT,
+			last_seen TEXT,
+			first_seen TEXT,
+			packet_count INTEGER DEFAULT 0
+		);
+
+		CREATE TABLE transmissions (
+			id INTEGER PRIMARY KEY AUTOINCREMENT,
+			raw_hex TEXT NOT NULL,
+			hash TEXT NOT NULL UNIQUE,
+			first_seen TEXT NOT NULL,
+			route_type INTEGER,
+			payload_type INTEGER,
+			payload_version INTEGER,
+			decoded_json TEXT,
+			created_at TEXT DEFAULT (datetime('now'))
+		);
+
+		CREATE TABLE observations (
+			id INTEGER PRIMARY KEY AUTOINCREMENT,
+			transmission_id INTEGER NOT NULL REFERENCES transmissions(id),
+			observer_id TEXT,
+			observer_name TEXT,
+			direction TEXT,
+			snr REAL,
+			rssi REAL,
+			score INTEGER,
+			path_json TEXT,
+			timestamp INTEGER NOT NULL
+		);
+	`
+	if _, err := conn.Exec(schema); err != nil {
+		t.Fatal(err)
+	}
+
+	return &DB{conn: conn, isV3: false}
+}
+
+func TestGetNodesRegionFilterV2(t *testing.T) {
+	db := setupTestDBV2(t)
+	defer db.Close()
+
+	now := time.Now().UTC()
+	recent := now.Add(-1 * time.Hour).Format(time.RFC3339)
+	recentEpoch := now.Add(-1 * time.Hour).Unix()
+
+	// Seed observer with IATA code
+	db.conn.Exec(`INSERT INTO observers (id, name, iata, last_seen, first_seen, packet_count)
+		VALUES ('obs-v2-1', 'V2 Observer', 'LAX', ?, '2026-01-01T00:00:00Z', 10)`, recent)
+
+	// Seed a node
+	db.conn.Exec(`INSERT INTO nodes (public_key, name, role, lat, lon, last_seen, first_seen, advert_count)
+		VALUES ('v2pubkey11223344', 'V2Node', 'repeater', 34.0, -118.0, ?, '2026-01-01T00:00:00Z', 5)`, recent)
+
+	// Seed an ADVERT transmission for the node
+	db.conn.Exec(`INSERT INTO transmissions (raw_hex, hash, first_seen, route_type, payload_type, decoded_json)
+		VALUES ('AABB', 'v2hash0001', ?, 1, 4, '{"pubKey":"v2pubkey11223344","name":"V2Node","type":"ADVERT"}')`, recent)
+
+	// Seed v2-style observation: observer_id references observers.id directly
+	db.conn.Exec(`INSERT INTO observations (transmission_id, observer_id, observer_name, snr, rssi, path_json, timestamp)
+		VALUES (1, 'obs-v2-1', 'V2 Observer', 10.0, -90, '[]', ?)`, recentEpoch)
+
+	t.Run("v2 region filter match", func(t *testing.T) {
+		nodes, total, _, err := db.GetNodes(50, 0, "", "", "", "", "", "LAX")
+		if err != nil {
+			t.Fatal(err)
+		}
+		if total != 1 {
+			t.Errorf("expected 1 node for LAX region (v2 schema), got %d", total)
+		}
+		if len(nodes) != 1 {
+			t.Fatalf("expected 1 node, got %d", len(nodes))
+		}
+		if nodes[0]["public_key"] != "v2pubkey11223344" {
+			t.Errorf("expected V2Node, got %v", nodes[0]["public_key"])
+		}
+	})
+
+	t.Run("v2 region filter no match", func(t *testing.T) {
+		_, total, _, err := db.GetNodes(50, 0, "", "", "", "", "", "JFK")
+		if err != nil {
+			t.Fatal(err)
+		}
+		if total != 0 {
+			t.Errorf("expected 0 nodes for JFK region (v2 schema), got %d", total)
+		}
+	})
 }
 
 func TestGetChannelMessagesDedup(t *testing.T) {
@@ -1375,3 +1554,367 @@ func TestNodeTelemetryFields(t *testing.T) {
 func TestMain(m *testing.M) {
 	os.Exit(m.Run())
 }
+
+func TestGetObserverMetrics(t *testing.T) {
+	db := setupTestDB(t)
+	seedTestData(t, db)
+
+	now := time.Now().UTC()
+	t1 := now.Add(-2 * time.Hour).Format(time.RFC3339)
+	t2 := now.Add(-1 * time.Hour).Format(time.RFC3339)
+	t3 := now.Format(time.RFC3339)
+
+	db.conn.Exec("INSERT INTO observer_metrics (observer_id, timestamp, noise_floor, tx_air_secs, rx_air_secs, recv_errors, battery_mv) VALUES (?, ?, ?, ?, ?, ?, ?)",
+		"obs1", t1, -112.5, 100, 500, 3, 3720)
+	db.conn.Exec("INSERT INTO observer_metrics (observer_id, timestamp, noise_floor, tx_air_secs, rx_air_secs, recv_errors) VALUES (?, ?, ?, ?, ?, ?)",
+		"obs1", t2, -110.0, 200, 800, 5)
+	db.conn.Exec("INSERT INTO observer_metrics (observer_id, timestamp, noise_floor, tx_air_secs, rx_air_secs, recv_errors) VALUES (?, ?, ?, ?, ?, ?)",
+		"obs1", t3, -108.0, 300, 1100, 8)
+	db.conn.Exec("INSERT INTO observer_metrics (observer_id, timestamp, noise_floor) VALUES (?, ?, ?)",
+		"obs2", t1, -115.0)
+
+	// Query all for obs1
+	since := now.Add(-3 * time.Hour).Format(time.RFC3339)
+	metrics, reboots, err := db.GetObserverMetrics("obs1", since, "", "5m", 3600)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(metrics) != 3 {
+		t.Errorf("expected 3 metrics, got %d", len(metrics))
+	}
+	if len(reboots) != 0 {
+		t.Errorf("expected 0 reboots, got %d", len(reboots))
+	}
+
+	// Verify first row has noise_floor
+	if metrics[0].NoiseFloor == nil || *metrics[0].NoiseFloor != -112.5 {
+		t.Errorf("first noise_floor = %v, want -112.5", metrics[0].NoiseFloor)
+	}
+	// First row: no delta possible (first sample)
+	if metrics[0].TxAirtimePct != nil {
+		t.Errorf("first sample should have nil tx_airtime_pct, got %v", *metrics[0].TxAirtimePct)
+	}
+
+	// Second row should have computed deltas
+	// TX: (200-100) / 3600 * 100 ≈ 2.78%
+	if metrics[1].TxAirtimePct == nil {
+		t.Errorf("second sample tx_airtime_pct should not be nil")
+	} else if *metrics[1].TxAirtimePct < 2.0 || *metrics[1].TxAirtimePct > 3.5 {
+		t.Errorf("second sample tx_airtime_pct = %v, want ~2.78", *metrics[1].TxAirtimePct)
+	}
+
+	// Query with until filter
+	metrics2, _, err := db.GetObserverMetrics("obs1", since, t2, "5m", 3600)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(metrics2) != 2 {
+		t.Errorf("expected 2 metrics with until filter, got %d", len(metrics2))
+	}
+}
+
+func TestGetMetricsSummary(t *testing.T) {
+	db := setupTestDB(t)
+	seedTestData(t, db)
+
+	now := time.Now().UTC()
+	t1 := now.Add(-2 * time.Hour).Format(time.RFC3339)
+	t2 := now.Add(-1 * time.Hour).Format(time.RFC3339)
+
+	db.conn.Exec("INSERT INTO observer_metrics (observer_id, timestamp, noise_floor, battery_mv) VALUES (?, ?, ?, ?)",
+		"obs1", t1, -112.0, 3720)
+	db.conn.Exec("INSERT INTO observer_metrics (observer_id, timestamp, noise_floor) VALUES (?, ?, ?)",
+		"obs1", t2, -108.0)
+	db.conn.Exec("INSERT INTO observer_metrics (observer_id, timestamp, noise_floor) VALUES (?, ?, ?)",
+		"obs2", t1, -115.0)
+
+	since := now.Add(-24 * time.Hour).Format(time.RFC3339)
+	summary, err := db.GetMetricsSummary(since)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(summary) != 2 {
+		t.Fatalf("expected 2 observers in summary, got %d", len(summary))
+	}
+
+	// Results sorted by max_nf DESC
+	// obs1 has max -108, obs2 has max -115
+	if summary[0].ObserverID != "obs1" {
+		t.Errorf("first observer should be obs1 (highest max NF), got %s", summary[0].ObserverID)
+	}
+	if summary[0].CurrentNF == nil || *summary[0].CurrentNF != -108.0 {
+		t.Errorf("obs1 current NF = %v, want -108.0", summary[0].CurrentNF)
+	}
+	if summary[0].SampleCount != 2 {
+		t.Errorf("obs1 sample count = %d, want 2", summary[0].SampleCount)
+	}
+	// Verify sparkline data is included
+	if len(summary[0].Sparkline) != 2 {
+		t.Errorf("obs1 sparkline length = %d, want 2", len(summary[0].Sparkline))
+	}
+	if len(summary[1].Sparkline) != 1 {
+		t.Errorf("obs2 sparkline length = %d, want 1", len(summary[1].Sparkline))
+	}
+	// Sparkline should be ordered by timestamp ASC
+	if summary[0].Sparkline[0] != nil && *summary[0].Sparkline[0] != -112.0 {
+		t.Errorf("obs1 sparkline[0] = %v, want -112.0", *summary[0].Sparkline[0])
+	}
+	if summary[0].Sparkline[1] != nil && *summary[0].Sparkline[1] != -108.0 {
+		t.Errorf("obs1 sparkline[1] = %v, want -108.0", *summary[0].Sparkline[1])
+	}
+}
+
+func TestObserverMetricsAPIEndpoints(t *testing.T) {
+	db := setupTestDB(t)
+	seedTestData(t, db)
+
+	now := time.Now().UTC()
+	t1 := now.Add(-1 * time.Hour).Format(time.RFC3339)
+
+	db.conn.Exec("INSERT INTO observer_metrics (observer_id, timestamp, noise_floor) VALUES (?, ?, ?)",
+		"obs1", t1, -112.0)
+
+	// Query directly to verify
+	metrics, _, err := db.GetObserverMetrics("obs1", "", "", "5m", 300)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(metrics) != 1 {
+		t.Errorf("expected 1 metric, got %d", len(metrics))
+	}
+}
+
+func TestComputeDeltas(t *testing.T) {
+	intPtr := func(v int) *int { return &v }
+	floatPtr := func(v float64) *float64 { return &v }
+
+	t.Run("empty input", func(t *testing.T) {
+		result, reboots, err := computeDeltas(nil, 300)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if result != nil {
+			t.Errorf("expected nil, got %v", result)
+		}
+		if reboots != nil {
+			t.Errorf("expected nil reboots, got %v", reboots)
+		}
+	})
+
+	t.Run("normal delta computation", func(t *testing.T) {
+		raw := []rawMetricsSample{
+			{Timestamp: "2026-04-05T00:00:00Z", NoiseFloor: floatPtr(-112), TxAirSecs: intPtr(100), RxAirSecs: intPtr(500), RecvErrors: intPtr(3), PacketsRecv: intPtr(1000)},
+			{Timestamp: "2026-04-05T00:05:00Z", NoiseFloor: floatPtr(-110), TxAirSecs: intPtr(115), RxAirSecs: intPtr(525), RecvErrors: intPtr(5), PacketsRecv: intPtr(1100)},
+		}
+		result, reboots, err := computeDeltas(raw, 300)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if len(result) != 2 {
+			t.Fatalf("expected 2 results, got %d", len(result))
+		}
+		if len(reboots) != 0 {
+			t.Errorf("expected 0 reboots, got %d", len(reboots))
+		}
+		// First sample: no deltas
+		if result[0].TxAirtimePct != nil {
+			t.Errorf("first sample should have nil tx_airtime_pct")
+		}
+		// Second sample: TX delta = 15 secs / 300 secs * 100 = 5%
+		if result[1].TxAirtimePct == nil {
+			t.Fatal("second sample tx_airtime_pct should not be nil")
+		}
+		if *result[1].TxAirtimePct != 5.0 {
+			t.Errorf("tx_airtime_pct = %v, want 5.0", *result[1].TxAirtimePct)
+		}
+		// RX delta = 25 secs / 300 secs * 100 ≈ 8.33%
+		if result[1].RxAirtimePct == nil {
+			t.Fatal("second sample rx_airtime_pct should not be nil")
+		}
+		if *result[1].RxAirtimePct < 8.3 || *result[1].RxAirtimePct > 8.4 {
+			t.Errorf("rx_airtime_pct = %v, want ~8.33", *result[1].RxAirtimePct)
+		}
+		// Error rate: delta_errors=2, delta_recv=100, rate = 2/(100+2)*100 ≈ 1.96%
+		if result[1].RecvErrorRate == nil {
+			t.Fatal("second sample recv_error_rate should not be nil")
+		}
+		if *result[1].RecvErrorRate < 1.9 || *result[1].RecvErrorRate > 2.0 {
+			t.Errorf("recv_error_rate = %v, want ~1.96", *result[1].RecvErrorRate)
+		}
+	})
+
+	t.Run("reboot detection", func(t *testing.T) {
+		raw := []rawMetricsSample{
+			{Timestamp: "2026-04-05T00:00:00Z", TxAirSecs: intPtr(1000), RxAirSecs: intPtr(5000)},
+			{Timestamp: "2026-04-05T00:05:00Z", TxAirSecs: intPtr(10), RxAirSecs: intPtr(20)}, // reboot!
+			{Timestamp: "2026-04-05T00:10:00Z", TxAirSecs: intPtr(25), RxAirSecs: intPtr(45)},
+		}
+		result, reboots, err := computeDeltas(raw, 300)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if len(reboots) != 1 {
+			t.Fatalf("expected 1 reboot, got %d", len(reboots))
+		}
+		if reboots[0] != "2026-04-05T00:05:00Z" {
+			t.Errorf("reboot timestamp = %s", reboots[0])
+		}
+		if !result[1].IsReboot {
+			t.Error("second sample should be marked as reboot")
+		}
+		// Reboot sample should have nil deltas
+		if result[1].TxAirtimePct != nil {
+			t.Error("reboot sample should have nil tx_airtime_pct")
+		}
+		// Third sample should have valid deltas from post-reboot baseline
+		if result[2].TxAirtimePct == nil {
+			t.Fatal("third sample tx_airtime_pct should not be nil")
+		}
+		if *result[2].TxAirtimePct != 5.0 { // 15/300*100
+			t.Errorf("third sample tx_airtime_pct = %v, want 5.0", *result[2].TxAirtimePct)
+		}
+	})
+
+	t.Run("gap detection", func(t *testing.T) {
+		raw := []rawMetricsSample{
+			{Timestamp: "2026-04-05T00:00:00Z", TxAirSecs: intPtr(100)},
+			{Timestamp: "2026-04-05T00:15:00Z", TxAirSecs: intPtr(200)}, // 15min gap > 2*300s
+		}
+		result, _, err := computeDeltas(raw, 300)
+		if err != nil {
+			t.Fatal(err)
+		}
+		// Gap sample should have nil deltas
+		if result[1].TxAirtimePct != nil {
+			t.Error("gap sample should have nil tx_airtime_pct")
+		}
+	})
+}
+
+func TestGetObserverMetricsResolution(t *testing.T) {
+	db := setupTestDB(t)
+	seedTestData(t, db)
+
+	db.conn.Exec("INSERT INTO observer_metrics (observer_id, timestamp, noise_floor, tx_air_secs) VALUES (?, ?, ?, ?)",
+		"obs1", "2026-04-05T00:00:00Z", -112.0, 100)
+	db.conn.Exec("INSERT INTO observer_metrics (observer_id, timestamp, noise_floor, tx_air_secs) VALUES (?, ?, ?, ?)",
+		"obs1", "2026-04-05T00:05:00Z", -110.0, 200)
+	db.conn.Exec("INSERT INTO observer_metrics (observer_id, timestamp, noise_floor, tx_air_secs) VALUES (?, ?, ?, ?)",
+		"obs1", "2026-04-05T01:00:00Z", -108.0, 500)
+	db.conn.Exec("INSERT INTO observer_metrics (observer_id, timestamp, noise_floor, tx_air_secs) VALUES (?, ?, ?, ?)",
+		"obs1", "2026-04-05T01:05:00Z", -106.0, 600)
+
+	// 5m resolution: all 4 rows
+	m5, _, err := db.GetObserverMetrics("obs1", "2026-04-04T00:00:00Z", "", "5m", 300)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(m5) != 4 {
+		t.Errorf("5m resolution: expected 4 rows, got %d", len(m5))
+	}
+
+	// 1h resolution: 2 buckets
+	m1h, _, err := db.GetObserverMetrics("obs1", "2026-04-04T00:00:00Z", "", "1h", 300)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(m1h) != 2 {
+		t.Errorf("1h resolution: expected 2 rows, got %d", len(m1h))
+	}
+
+	// 1d resolution: 1 bucket
+	m1d, _, err := db.GetObserverMetrics("obs1", "2026-04-04T00:00:00Z", "", "1d", 300)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(m1d) != 1 {
+		t.Errorf("1d resolution: expected 1 row, got %d", len(m1d))
+	}
+}
+
+func TestHourlyResolutionDeltasNotNull(t *testing.T) {
+	db := setupTestDB(t)
+	seedTestData(t, db)
+
+	// Two hourly buckets, each with one sample. With old MAX+hardcoded gap threshold,
+	// the 3600s gap would exceed sampleInterval*2 (600s) and deltas would be null.
+	db.conn.Exec("INSERT INTO observer_metrics (observer_id, timestamp, noise_floor, tx_air_secs, rx_air_secs, recv_errors, packets_sent, packets_recv) VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
+		"obs_hr", "2026-04-05T10:00:00Z", -110.0, 100, 200, 5, 50, 100)
+	db.conn.Exec("INSERT INTO observer_metrics (observer_id, timestamp, noise_floor, tx_air_secs, rx_air_secs, recv_errors, packets_sent, packets_recv) VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
+		"obs_hr", "2026-04-05T11:00:00Z", -108.0, 200, 400, 10, 80, 200)
+
+	m, _, err := db.GetObserverMetrics("obs_hr", "2026-04-04T00:00:00Z", "", "1h", 300)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(m) != 2 {
+		t.Fatalf("expected 2 rows, got %d", len(m))
+	}
+	// Second row should have computed deltas (not null)
+	if m[1].TxAirtimePct == nil {
+		t.Error("1h resolution: tx_airtime_pct should not be nil — gap threshold must scale with resolution")
+	}
+}
+
+func TestLastValuePreservesReboot(t *testing.T) {
+	db := setupTestDB(t)
+	seedTestData(t, db)
+
+	// Hour bucket with two samples: pre-reboot (high) and post-reboot (low).
+	// With MAX(), the pre-reboot value wins and the reboot is hidden.
+	// With LAST (latest timestamp), the post-reboot value wins.
+	db.conn.Exec("INSERT INTO observer_metrics (observer_id, timestamp, noise_floor, tx_air_secs, rx_air_secs, recv_errors, packets_sent, packets_recv) VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
+		"obs_rb", "2026-04-05T10:00:00Z", -110.0, 1000, 2000, 500, 400, 800) // pre-reboot baseline
+	db.conn.Exec("INSERT INTO observer_metrics (observer_id, timestamp, noise_floor, tx_air_secs, rx_air_secs, recv_errors, packets_sent, packets_recv) VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
+		"obs_rb", "2026-04-05T10:20:00Z", -110.0, 5000, 6000, 900, 700, 1200) // pre-reboot peak
+	db.conn.Exec("INSERT INTO observer_metrics (observer_id, timestamp, noise_floor, tx_air_secs, rx_air_secs, recv_errors, packets_sent, packets_recv) VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
+		"obs_rb", "2026-04-05T10:40:00Z", -110.0, 10, 20, 1, 5, 10) // post-reboot (counter reset)
+
+	// Next hour bucket
+	db.conn.Exec("INSERT INTO observer_metrics (observer_id, timestamp, noise_floor, tx_air_secs, rx_air_secs, recv_errors, packets_sent, packets_recv) VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
+		"obs_rb", "2026-04-05T11:00:00Z", -108.0, 100, 120, 5, 20, 50)
+
+	m, reboots, err := db.GetObserverMetrics("obs_rb", "2026-04-04T00:00:00Z", "", "1h", 300)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(m) != 2 {
+		t.Fatalf("expected 2 rows, got %d", len(m))
+	}
+
+	// First bucket should use the LAST value (post-reboot: tx_air_secs=10).
+	// Second bucket (tx_air_secs=100) is a normal increase from 10→100.
+	// With LAST-value semantics, the second bucket should have valid deltas (not a reboot).
+	// With MAX(), first bucket would have tx_air_secs=5000, and second=100 would
+	// trigger a false reboot detection.
+	if m[1].IsReboot {
+		t.Error("second bucket should NOT be flagged as reboot with LAST-value aggregation")
+	}
+	if m[1].TxAirtimePct == nil {
+		t.Error("second bucket should have non-nil tx_airtime_pct")
+	}
+	_ = reboots // reboots list is informational
+}
+
+func TestParseWindowDuration(t *testing.T) {
+	tests := []struct {
+		input string
+		want  time.Duration
+		err   bool
+	}{
+		{"1h", time.Hour, false},
+		{"24h", 24 * time.Hour, false},
+		{"3d", 3 * 24 * time.Hour, false},
+		{"30d", 30 * 24 * time.Hour, false},
+		{"invalid", 0, true},
+	}
+	for _, tc := range tests {
+		got, err := parseWindowDuration(tc.input)
+		if tc.err && err == nil {
+			t.Errorf("parseWindowDuration(%q) expected error", tc.input)
+		}
+		if !tc.err && got != tc.want {
+			t.Errorf("parseWindowDuration(%q) = %v, want %v", tc.input, got, tc.want)
+		}
+	}
+}

cmd/server/decoder.go

@@ -9,6 +9,8 @@ import (
 	"math"
 	"strings"
 	"time"
+
+	"github.com/meshcore-analyzer/sigvalidate"
 )
 
 // Route type constants (header bits 1-0)
@@ -60,9 +62,10 @@ type TransportCodes struct {
 
 // Path holds decoded path/hop information.
 type Path struct {
-	HashSize  int      `json:"hashSize"`
-	HashCount int      `json:"hashCount"`
-	Hops      []string `json:"hops"`
+	HashSize      int      `json:"hashSize"`
+	HashCount     int      `json:"hashCount"`
+	Hops          []string `json:"hops"`
+	HopsCompleted *int     `json:"hopsCompleted,omitempty"`
 }
 
 // AdvertFlags holds decoded advert flag bits.
@@ -91,6 +94,7 @@ type Payload struct {
 	Timestamp       uint32       `json:"timestamp,omitempty"`
 	TimestampISO    string       `json:"timestampISO,omitempty"`
 	Signature       string       `json:"signature,omitempty"`
+	SignatureValid  *bool        `json:"signatureValid,omitempty"`
 	Flags           *AdvertFlags `json:"flags,omitempty"`
 	Lat             *float64     `json:"lat,omitempty"`
 	Lon             *float64     `json:"lon,omitempty"`
@@ -187,7 +191,7 @@ func decodeAck(buf []byte) Payload {
 	}
 }
 
-func decodeAdvert(buf []byte) Payload {
+func decodeAdvert(buf []byte, validateSignatures bool) Payload {
 	if len(buf) < 100 {
 		return Payload{Type: "ADVERT", Error: "too short for advert", RawHex: hex.EncodeToString(buf)}
 	}
@@ -205,6 +209,11 @@ func decodeAdvert(buf []byte) Payload {
 		Signature:    signature,
 	}
 
+	if validateSignatures {
+		valid := sigvalidate.ValidateAdvertSignature(buf[0:32], buf[36:100], timestamp, appdata)
+		p.SignatureValid = &valid
+	}
+
 	if len(appdata) > 0 {
 		flags := appdata[0]
 		advType := int(flags & 0x0F)
@@ -307,7 +316,7 @@ func decodeTrace(buf []byte) Payload {
 	return p
 }
 
-func decodePayload(payloadType int, buf []byte) Payload {
+func decodePayload(payloadType int, buf []byte, validateSignatures bool) Payload {
 	switch payloadType {
 	case PayloadREQ:
 		return decodeEncryptedPayload("REQ", buf)
@@ -318,7 +327,7 @@ func decodePayload(payloadType int, buf []byte) Payload {
 	case PayloadACK:
 		return decodeAck(buf)
 	case PayloadADVERT:
-		return decodeAdvert(buf)
+		return decodeAdvert(buf, validateSignatures)
 	case PayloadGRP_TXT:
 		return decodeGrpTxt(buf)
 	case PayloadANON_REQ:
@@ -333,7 +342,7 @@ func decodePayload(payloadType int, buf []byte) Payload {
 }
 
 // DecodePacket decodes a hex-encoded MeshCore packet.
-func DecodePacket(hexString string) (*DecodedPacket, error) {
+func DecodePacket(hexString string, validateSignatures bool) (*DecodedPacket, error) {
 	hexString = strings.ReplaceAll(hexString, " ", "")
 	hexString = strings.ReplaceAll(hexString, "\n", "")
 	hexString = strings.ReplaceAll(hexString, "\r", "")
@@ -371,12 +380,17 @@ func DecodePacket(hexString string) (*DecodedPacket, error) {
 	offset += bytesConsumed
 
 	payloadBuf := buf[offset:]
-	payload := decodePayload(header.PayloadType, payloadBuf)
+	payload := decodePayload(header.PayloadType, payloadBuf, validateSignatures)
 
 	// TRACE packets store hop IDs in the payload (buf[9:]) rather than the header
 	// path field. The header path byte still encodes hashSize in bits 6-7, which
 	// we use to split the payload path data into individual hop prefixes.
+	// The header path contains SNR bytes — one per hop that actually forwarded.
+	// We expose hopsCompleted (count of SNR bytes) so consumers can distinguish
+	// how far the trace got vs the full intended route.
 	if header.PayloadType == PayloadTRACE && payload.PathData != "" {
+		// The header path hops count represents SNR entries = completed hops
+		hopsCompleted := path.HashCount
 		pathBytes, err := hex.DecodeString(payload.PathData)
 		if err == nil && path.HashSize > 0 {
 			hops := make([]string, 0, len(pathBytes)/path.HashSize)
@@ -385,9 +399,20 @@ func DecodePacket(hexString string) (*DecodedPacket, error) {
 			}
 			path.Hops = hops
 			path.HashCount = len(hops)
+			path.HopsCompleted = &hopsCompleted
 		}
 	}
 
+	// Zero-hop direct packets have hash_count=0 (lower 6 bits of pathByte),
+	// which makes the generic formula yield a bogus hashSize. Reset to 0
+	// (unknown) so API consumers get correct data. We mask with 0x3F to check
+	// only hash_count, matching the JS frontend approach — the upper hash_size
+	// bits are meaningless when there are no hops. Skip TRACE packets — they
+	// use hashSize to parse hops from the payload above.
+	if (header.RouteType == RouteDirect || header.RouteType == RouteTransportDirect) && pathByte&0x3F == 0 && header.PayloadType != PayloadTRACE {
+		path.HashSize = 0
+	}
+
 	return &DecodedPacket{
 		Header:         header,
 		TransportCodes: tc,
@@ -397,6 +422,106 @@ func DecodePacket(hexString string) (*DecodedPacket, error) {
 	}, nil
 }
 
+// HexRange represents a labeled byte range for the hex breakdown visualization.
+type HexRange struct {
+	Start int    `json:"start"`
+	End   int    `json:"end"`
+	Label string `json:"label"`
+}
+
+// Breakdown holds colored byte ranges returned by the packet detail endpoint.
+type Breakdown struct {
+	Ranges []HexRange `json:"ranges"`
+}
+
+// BuildBreakdown computes labeled byte ranges for each section of a MeshCore packet.
+// The returned ranges are consumed by createColoredHexDump() and buildHexLegend()
+// in the frontend (public/app.js).
+func BuildBreakdown(hexString string) *Breakdown {
+	hexString = strings.ReplaceAll(hexString, " ", "")
+	hexString = strings.ReplaceAll(hexString, "\n", "")
+	hexString = strings.ReplaceAll(hexString, "\r", "")
+	buf, err := hex.DecodeString(hexString)
+	if err != nil || len(buf) < 2 {
+		return &Breakdown{Ranges: []HexRange{}}
+	}
+
+	var ranges []HexRange
+	offset := 0
+
+	// Byte 0: Header
+	ranges = append(ranges, HexRange{Start: 0, End: 0, Label: "Header"})
+	offset = 1
+
+	header := decodeHeader(buf[0])
+
+	// Bytes 1-4: Transport Codes (TRANSPORT_FLOOD / TRANSPORT_DIRECT only)
+	if isTransportRoute(header.RouteType) {
+		if len(buf) < offset+4 {
+			return &Breakdown{Ranges: ranges}
+		}
+		ranges = append(ranges, HexRange{Start: offset, End: offset + 3, Label: "Transport Codes"})
+		offset += 4
+	}
+
+	if offset >= len(buf) {
+		return &Breakdown{Ranges: ranges}
+	}
+
+	// Next byte: Path Length (bits 7-6 = hashSize-1, bits 5-0 = hashCount)
+	ranges = append(ranges, HexRange{Start: offset, End: offset, Label: "Path Length"})
+	pathByte := buf[offset]
+	offset++
+
+	hashSize := int(pathByte>>6) + 1
+	hashCount := int(pathByte & 0x3F)
+	pathBytes := hashSize * hashCount
+
+	// Path hops
+	if hashCount > 0 && offset+pathBytes <= len(buf) {
+		ranges = append(ranges, HexRange{Start: offset, End: offset + pathBytes - 1, Label: "Path"})
+	}
+	offset += pathBytes
+
+	if offset >= len(buf) {
+		return &Breakdown{Ranges: ranges}
+	}
+
+	payloadStart := offset
+
+	// Payload — break ADVERT into named sub-fields; everything else is one Payload range
+	if header.PayloadType == PayloadADVERT && len(buf)-payloadStart >= 100 {
+		ranges = append(ranges, HexRange{Start: payloadStart, End: payloadStart + 31, Label: "PubKey"})
+		ranges = append(ranges, HexRange{Start: payloadStart + 32, End: payloadStart + 35, Label: "Timestamp"})
+		ranges = append(ranges, HexRange{Start: payloadStart + 36, End: payloadStart + 99, Label: "Signature"})
+
+		appStart := payloadStart + 100
+		if appStart < len(buf) {
+			ranges = append(ranges, HexRange{Start: appStart, End: appStart, Label: "Flags"})
+			appFlags := buf[appStart]
+			fOff := appStart + 1
+			if appFlags&0x10 != 0 && fOff+8 <= len(buf) {
+				ranges = append(ranges, HexRange{Start: fOff, End: fOff + 3, Label: "Latitude"})
+				ranges = append(ranges, HexRange{Start: fOff + 4, End: fOff + 7, Label: "Longitude"})
+				fOff += 8
+			}
+			if appFlags&0x20 != 0 && fOff+2 <= len(buf) {
+				fOff += 2
+			}
+			if appFlags&0x40 != 0 && fOff+2 <= len(buf) {
+				fOff += 2
+			}
+			if appFlags&0x80 != 0 && fOff < len(buf) {
+				ranges = append(ranges, HexRange{Start: fOff, End: len(buf) - 1, Label: "Name"})
+			}
+		}
+	} else {
+		ranges = append(ranges, HexRange{Start: payloadStart, End: len(buf) - 1, Label: "Payload"})
+	}
+
+	return &Breakdown{Ranges: ranges}
+}
+
 // ComputeContentHash computes the SHA-256-based content hash (first 16 hex chars).
 func ComputeContentHash(rawHex string) string {
 	buf, err := hex.DecodeString(rawHex)

cmd/server/decoder_test.go

@@ -1,7 +1,11 @@
 package main
 
 import (
+	"crypto/ed25519"
+	"encoding/binary"
 	"testing"
+
+	"github.com/meshcore-analyzer/sigvalidate"
 )
 
 func TestDecodeHeader_TransportFlood(t *testing.T) {
@@ -65,7 +69,7 @@ func TestDecodePacket_TransportFloodHasCodes(t *testing.T) {
 	// Path byte: 0x00 (hashSize=1, hashCount=0)
 	// Payload: at least some bytes for GRP_TXT
 	hex := "14AABBCCDD00112233445566778899"
-	pkt, err := DecodePacket(hex)
+	pkt, err := DecodePacket(hex, false)
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -85,7 +89,7 @@ func TestDecodePacket_FloodHasNoCodes(t *testing.T) {
 	// Path byte: 0x00 (no hops)
 	// Some payload bytes
 	hex := "110011223344556677889900AABBCCDD"
-	pkt, err := DecodePacket(hex)
+	pkt, err := DecodePacket(hex, false)
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -93,3 +97,398 @@ func TestDecodePacket_FloodHasNoCodes(t *testing.T) {
 		t.Error("expected no transport codes for FLOOD route")
 	}
 }
+
+func TestBuildBreakdown_InvalidHex(t *testing.T) {
+	b := BuildBreakdown("not-hex!")
+	if len(b.Ranges) != 0 {
+		t.Errorf("expected empty ranges for invalid hex, got %d", len(b.Ranges))
+	}
+}
+
+func TestBuildBreakdown_TooShort(t *testing.T) {
+	b := BuildBreakdown("11") // 1 byte — no path byte
+	if len(b.Ranges) != 0 {
+		t.Errorf("expected empty ranges for too-short packet, got %d", len(b.Ranges))
+	}
+}
+
+func TestBuildBreakdown_FloodNonAdvert(t *testing.T) {
+	// Header 0x15: route=1/FLOOD, payload=5/GRP_TXT
+	// PathByte 0x01: 1 hop, 1-byte hash
+	// PathHop: AA
+	// Payload: FF0011
+	b := BuildBreakdown("1501AAFFFF00")
+	labels := rangeLabels(b.Ranges)
+	expect := []string{"Header", "Path Length", "Path", "Payload"}
+	if !equalLabels(labels, expect) {
+		t.Errorf("expected labels %v, got %v", expect, labels)
+	}
+	// Verify byte positions
+	assertRange(t, b.Ranges, "Header", 0, 0)
+	assertRange(t, b.Ranges, "Path Length", 1, 1)
+	assertRange(t, b.Ranges, "Path", 2, 2)
+	assertRange(t, b.Ranges, "Payload", 3, 5)
+}
+
+func TestBuildBreakdown_TransportFlood(t *testing.T) {
+	// Header 0x14: route=0/TRANSPORT_FLOOD, payload=5/GRP_TXT
+	// TransportCodes: AABBCCDD (4 bytes)
+	// PathByte 0x01: 1 hop, 1-byte hash
+	// PathHop: EE
+	// Payload: FF00
+	b := BuildBreakdown("14AABBCCDD01EEFF00")
+	assertRange(t, b.Ranges, "Header", 0, 0)
+	assertRange(t, b.Ranges, "Transport Codes", 1, 4)
+	assertRange(t, b.Ranges, "Path Length", 5, 5)
+	assertRange(t, b.Ranges, "Path", 6, 6)
+	assertRange(t, b.Ranges, "Payload", 7, 8)
+}
+
+func TestBuildBreakdown_FloodNoHops(t *testing.T) {
+	// Header 0x15: FLOOD/GRP_TXT; PathByte 0x00: 0 hops; Payload: AABB
+	b := BuildBreakdown("150000AABB")
+	assertRange(t, b.Ranges, "Header", 0, 0)
+	assertRange(t, b.Ranges, "Path Length", 1, 1)
+	// No Path range since hashCount=0
+	for _, r := range b.Ranges {
+		if r.Label == "Path" {
+			t.Error("expected no Path range for zero-hop packet")
+		}
+	}
+	assertRange(t, b.Ranges, "Payload", 2, 4)
+}
+
+func TestBuildBreakdown_AdvertBasic(t *testing.T) {
+	// Header 0x11: FLOOD/ADVERT
+	// PathByte 0x01: 1 hop, 1-byte hash
+	// PathHop: AA
+	// Payload: 100 bytes (PubKey32 + Timestamp4 + Signature64) + Flags=0x02 (repeater, no extras)
+	pubkey := repeatHex("AB", 32)
+	ts := "00000000" // 4 bytes
+	sig := repeatHex("CD", 64)
+	flags := "02"
+	hex := "1101AA" + pubkey + ts + sig + flags
+	b := BuildBreakdown(hex)
+	assertRange(t, b.Ranges, "Header", 0, 0)
+	assertRange(t, b.Ranges, "Path Length", 1, 1)
+	assertRange(t, b.Ranges, "Path", 2, 2)
+	assertRange(t, b.Ranges, "PubKey", 3, 34)
+	assertRange(t, b.Ranges, "Timestamp", 35, 38)
+	assertRange(t, b.Ranges, "Signature", 39, 102)
+	assertRange(t, b.Ranges, "Flags", 103, 103)
+}
+
+func TestBuildBreakdown_AdvertWithLocation(t *testing.T) {
+	// flags=0x12: hasLocation bit set
+	pubkey := repeatHex("00", 32)
+	ts := "00000000"
+	sig := repeatHex("00", 64)
+	flags := "12" // 0x10 = hasLocation
+	latBytes := "00000000"
+	lonBytes := "00000000"
+	hex := "1101AA" + pubkey + ts + sig + flags + latBytes + lonBytes
+	b := BuildBreakdown(hex)
+	assertRange(t, b.Ranges, "Latitude", 104, 107)
+	assertRange(t, b.Ranges, "Longitude", 108, 111)
+}
+
+func TestBuildBreakdown_AdvertWithName(t *testing.T) {
+	// flags=0x82: hasName bit set
+	pubkey := repeatHex("00", 32)
+	ts := "00000000"
+	sig := repeatHex("00", 64)
+	flags := "82" // 0x80 = hasName
+	name := "4E6F6465" // "Node" in hex
+	hex := "1101AA" + pubkey + ts + sig + flags + name
+	b := BuildBreakdown(hex)
+	assertRange(t, b.Ranges, "Name", 104, 107)
+}
+
+// helpers
+
+func rangeLabels(ranges []HexRange) []string {
+	out := make([]string, len(ranges))
+	for i, r := range ranges {
+		out[i] = r.Label
+	}
+	return out
+}
+
+func equalLabels(a, b []string) bool {
+	if len(a) != len(b) {
+		return false
+	}
+	for i := range a {
+		if a[i] != b[i] {
+			return false
+		}
+	}
+	return true
+}
+
+func assertRange(t *testing.T, ranges []HexRange, label string, wantStart, wantEnd int) {
+	t.Helper()
+	for _, r := range ranges {
+		if r.Label == label {
+			if r.Start != wantStart || r.End != wantEnd {
+				t.Errorf("range %q: want [%d,%d], got [%d,%d]", label, wantStart, wantEnd, r.Start, r.End)
+			}
+			return
+		}
+	}
+	t.Errorf("range %q not found in %v", label, rangeLabels(ranges))
+}
+
+func TestZeroHopDirectHashSize(t *testing.T) {
+	// DIRECT (RouteType=2) + REQ (PayloadType=0) → header byte = 0x02
+	// pathByte=0x00 → hash_count=0, hash_size bits=0 → should get HashSize=0
+	// Need at least a few payload bytes after pathByte.
+	hex := "02" + "00" + repeatHex("AA", 20)
+	pkt, err := DecodePacket(hex, false)
+	if err != nil {
+		t.Fatalf("DecodePacket failed: %v", err)
+	}
+	if pkt.Path.HashSize != 0 {
+		t.Errorf("DIRECT zero-hop: want HashSize=0, got %d", pkt.Path.HashSize)
+	}
+}
+
+func TestZeroHopDirectHashSizeWithNonZeroUpperBits(t *testing.T) {
+	// DIRECT (RouteType=2) + REQ (PayloadType=0) → header byte = 0x02
+	// pathByte=0x40 → hash_count=0, hash_size bits=01 → should still get HashSize=0
+	// because hash_count is zero (lower 6 bits are 0).
+	hex := "02" + "40" + repeatHex("AA", 20)
+	pkt, err := DecodePacket(hex, false)
+	if err != nil {
+		t.Fatalf("DecodePacket failed: %v", err)
+	}
+	if pkt.Path.HashSize != 0 {
+		t.Errorf("DIRECT zero-hop with hash_size bits set: want HashSize=0, got %d", pkt.Path.HashSize)
+	}
+}
+
+func TestZeroHopTransportDirectHashSize(t *testing.T) {
+	// TRANSPORT_DIRECT (RouteType=3) + REQ (PayloadType=0) → header byte = 0x03
+	// 4 bytes transport codes + pathByte=0x00 → hash_count=0 → should get HashSize=0
+	hex := "03" + "11223344" + "00" + repeatHex("AA", 20)
+	pkt, err := DecodePacket(hex, false)
+	if err != nil {
+		t.Fatalf("DecodePacket failed: %v", err)
+	}
+	if pkt.Path.HashSize != 0 {
+		t.Errorf("TRANSPORT_DIRECT zero-hop: want HashSize=0, got %d", pkt.Path.HashSize)
+	}
+}
+
+func TestZeroHopTransportDirectHashSizeWithNonZeroUpperBits(t *testing.T) {
+	// TRANSPORT_DIRECT (RouteType=3) + REQ (PayloadType=0) → header byte = 0x03
+	// 4 bytes transport codes + pathByte=0xC0 → hash_count=0, hash_size bits=11 → should still get HashSize=0
+	hex := "03" + "11223344" + "C0" + repeatHex("AA", 20)
+	pkt, err := DecodePacket(hex, false)
+	if err != nil {
+		t.Fatalf("DecodePacket failed: %v", err)
+	}
+	if pkt.Path.HashSize != 0 {
+		t.Errorf("TRANSPORT_DIRECT zero-hop with hash_size bits set: want HashSize=0, got %d", pkt.Path.HashSize)
+	}
+}
+
+func TestNonDirectZeroPathByteKeepsHashSize(t *testing.T) {
+	// FLOOD (RouteType=1) + REQ (PayloadType=0) → header byte = 0x01
+	// pathByte=0x00 → even though hash_count=0, non-DIRECT should keep HashSize=1
+	hex := "01" + "00" + repeatHex("AA", 20)
+	pkt, err := DecodePacket(hex, false)
+	if err != nil {
+		t.Fatalf("DecodePacket failed: %v", err)
+	}
+	if pkt.Path.HashSize != 1 {
+		t.Errorf("FLOOD zero pathByte: want HashSize=1 (unchanged), got %d", pkt.Path.HashSize)
+	}
+}
+
+func TestDirectNonZeroHopKeepsHashSize(t *testing.T) {
+	// DIRECT (RouteType=2) + REQ (PayloadType=0) → header byte = 0x02
+	// pathByte=0x01 → hash_count=1, hash_size=1 → should keep HashSize=1
+	// Need 1 hop hash byte after pathByte.
+	hex := "02" + "01" + repeatHex("BB", 21)
+	pkt, err := DecodePacket(hex, false)
+	if err != nil {
+		t.Fatalf("DecodePacket failed: %v", err)
+	}
+	if pkt.Path.HashSize != 1 {
+		t.Errorf("DIRECT with 1 hop: want HashSize=1, got %d", pkt.Path.HashSize)
+	}
+}
+
+func repeatHex(byteHex string, n int) string {
+	s := ""
+	for i := 0; i < n; i++ {
+		s += byteHex
+	}
+	return s
+}
+
+func TestDecodePacket_TraceHopsCompleted(t *testing.T) {
+	// Build a TRACE packet:
+	// header: route=FLOOD(1), payload=TRACE(9), version=0 → (0<<6)|(9<<2)|1 = 0x25
+	// path_length: hash_size bits=0b00 (1-byte), hash_count=2 (2 SNR bytes) → 0x02
+	// path: 2 SNR bytes: 0xAA, 0xBB
+	// payload: tag(4 LE) + authCode(4 LE) + flags(1) + 4 hop hashes (1 byte each)
+	hex := "2502AABB" + // header + path_length + 2 SNR bytes
+		"01000000" + // tag = 1
+		"02000000" + // authCode = 2
+		"00" + // flags = 0
+		"DEADBEEF" // 4 hops (1-byte hash each)
+
+	pkt, err := DecodePacket(hex, false)
+	if err != nil {
+		t.Fatalf("DecodePacket error: %v", err)
+	}
+	if pkt.Payload.Type != "TRACE" {
+		t.Fatalf("expected TRACE, got %s", pkt.Payload.Type)
+	}
+	// Full intended route = 4 hops from payload
+	if len(pkt.Path.Hops) != 4 {
+		t.Errorf("expected 4 hops, got %d: %v", len(pkt.Path.Hops), pkt.Path.Hops)
+	}
+	// HopsCompleted = 2 (from header path SNR count)
+	if pkt.Path.HopsCompleted == nil {
+		t.Fatal("expected HopsCompleted to be set")
+	}
+	if *pkt.Path.HopsCompleted != 2 {
+		t.Errorf("expected HopsCompleted=2, got %d", *pkt.Path.HopsCompleted)
+	}
+}
+
+func TestDecodePacket_TraceNoSNR(t *testing.T) {
+	// TRACE with 0 SNR bytes (trace hasn't been forwarded yet)
+	// path_length: hash_size=0b00 (1-byte), hash_count=0 → 0x00
+	hex := "2500" + // header + path_length (0 hops in header)
+		"01000000" + // tag
+		"02000000" + // authCode
+		"00" + // flags
+		"AABBCC" // 3 hops intended
+
+	pkt, err := DecodePacket(hex, false)
+	if err != nil {
+		t.Fatalf("DecodePacket error: %v", err)
+	}
+	if pkt.Path.HopsCompleted == nil {
+		t.Fatal("expected HopsCompleted to be set")
+	}
+	if *pkt.Path.HopsCompleted != 0 {
+		t.Errorf("expected HopsCompleted=0, got %d", *pkt.Path.HopsCompleted)
+	}
+	if len(pkt.Path.Hops) != 3 {
+		t.Errorf("expected 3 hops, got %d", len(pkt.Path.Hops))
+	}
+}
+
+func TestDecodePacket_TraceFullyCompleted(t *testing.T) {
+	// TRACE where all hops completed (SNR count = hop count)
+	// path_length: hash_size=0b00 (1-byte), hash_count=3 → 0x03
+	hex := "2503AABBCC" + // header + path_length + 3 SNR bytes
+		"01000000" + // tag
+		"02000000" + // authCode
+		"00" + // flags
+		"DDEEFF" // 3 hops intended
+
+	pkt, err := DecodePacket(hex, false)
+	if err != nil {
+		t.Fatalf("DecodePacket error: %v", err)
+	}
+	if pkt.Path.HopsCompleted == nil {
+		t.Fatal("expected HopsCompleted to be set")
+	}
+	if *pkt.Path.HopsCompleted != 3 {
+		t.Errorf("expected HopsCompleted=3, got %d", *pkt.Path.HopsCompleted)
+	}
+	if len(pkt.Path.Hops) != 3 {
+		t.Errorf("expected 3 hops, got %d", len(pkt.Path.Hops))
+	}
+}
+
+func TestValidateAdvertSignature(t *testing.T) {
+	pub, priv, err := ed25519.GenerateKey(nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	var timestamp uint32 = 1234567890
+	appdata := []byte{0x02, 0x11, 0x22}
+
+	message := make([]byte, 32+4+len(appdata))
+	copy(message[0:32], pub)
+	binary.LittleEndian.PutUint32(message[32:36], timestamp)
+	copy(message[36:], appdata)
+
+	sig := ed25519.Sign(priv, message)
+
+	// Valid signature
+	if !sigvalidate.ValidateAdvertSignature(pub, sig, timestamp, appdata) {
+		t.Error("expected valid signature")
+	}
+
+	// Tampered appdata
+	if sigvalidate.ValidateAdvertSignature(pub, sig, timestamp, []byte{0x03, 0x11, 0x22}) {
+		t.Error("expected invalid with tampered appdata")
+	}
+
+	// Wrong timestamp
+	if sigvalidate.ValidateAdvertSignature(pub, sig, timestamp+1, appdata) {
+		t.Error("expected invalid with wrong timestamp")
+	}
+
+	// Short pubkey
+	if sigvalidate.ValidateAdvertSignature([]byte{0xAA}, sig, timestamp, appdata) {
+		t.Error("expected false for short pubkey")
+	}
+
+	// Short signature
+	if sigvalidate.ValidateAdvertSignature(pub, []byte{0xBB}, timestamp, appdata) {
+		t.Error("expected false for short signature")
+	}
+}
+
+func TestDecodeAdvertWithSignatureValidation(t *testing.T) {
+	pub, priv, err := ed25519.GenerateKey(nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	var timestamp uint32 = 1000000
+	appdata := []byte{0x02} // repeater type
+
+	message := make([]byte, 32+4+len(appdata))
+	copy(message[0:32], pub)
+	binary.LittleEndian.PutUint32(message[32:36], timestamp)
+	copy(message[36:], appdata)
+	sig := ed25519.Sign(priv, message)
+
+	// Build advert buffer: pubkey(32) + timestamp(4) + signature(64) + appdata
+	buf := make([]byte, 0, 101)
+	buf = append(buf, pub...)
+	ts := make([]byte, 4)
+	binary.LittleEndian.PutUint32(ts, timestamp)
+	buf = append(buf, ts...)
+	buf = append(buf, sig...)
+	buf = append(buf, appdata...)
+
+	// With validation
+	p := decodeAdvert(buf, true)
+	if p.Error != "" {
+		t.Fatalf("decode error: %s", p.Error)
+	}
+	if p.SignatureValid == nil {
+		t.Fatal("SignatureValid should be set when validation enabled")
+	}
+	if !*p.SignatureValid {
+		t.Error("expected valid signature")
+	}
+
+	// Without validation
+	p2 := decodeAdvert(buf, false)
+	if p2.SignatureValid != nil {
+		t.Error("SignatureValid should be nil when validation disabled")
+	}
+}

cmd/server/eviction_test.go

@@ -162,24 +162,50 @@ func TestEvictStale_NoEvictionWhenDisabled(t *testing.T) {
 
 func TestEvictStale_MemoryBasedEviction(t *testing.T) {
 	now := time.Now().UTC()
-	// Create enough packets to exceed a small memory limit
-	// 1000 packets * 5KB + 2000 obs * 500B ≈ 6MB
 	store := makeTestStore(1000, now.Add(-1*time.Hour), 0)
-	// All packets are recent (1h old) so time-based won't trigger
+	// All packets are recent (1h old) so time-based won't trigger.
 	store.retentionHours = 24
-	store.maxMemoryMB = 3 // ~3MB limit, should evict roughly half
+	store.maxMemoryMB = 3
+	// Inject deterministic estimator: simulates 6MB (over 3MB limit).
+	// Uses packet count so it scales correctly after eviction.
+	store.memoryEstimator = func() float64 {
+		return float64(len(store.packets)*5120+store.totalObs*500) / 1048576.0
+	}
 
 	evicted := store.EvictStale()
 	if evicted == 0 {
 		t.Fatal("expected some evictions for memory cap")
 	}
-	// After eviction, estimated memory should be <= 3MB
 	estMB := store.estimatedMemoryMB()
-	if estMB > 3.5 { // small tolerance
+	if estMB > 3.5 {
 		t.Fatalf("expected <=3.5MB after eviction, got %.1fMB", estMB)
 	}
 }
 
+// TestEvictStale_MemoryBasedEviction_UnderestimatedHeap verifies that eviction
+// fires correctly when actual heap is much larger than a formula-based estimate
+// would report — the scenario that caused OOM kills in production.
+func TestEvictStale_MemoryBasedEviction_UnderestimatedHeap(t *testing.T) {
+	now := time.Now().UTC()
+	store := makeTestStore(1000, now.Add(-1*time.Hour), 0)
+	store.retentionHours = 24
+	store.maxMemoryMB = 500
+	// Simulate actual heap 5x over budget (like production: ~5GB actual vs ~1GB limit).
+	store.memoryEstimator = func() float64 {
+		return 2500.0 // 2500MB actual vs 500MB limit
+	}
+
+	evicted := store.EvictStale()
+	if evicted == 0 {
+		t.Fatal("expected evictions when heap is 5x over limit")
+	}
+	// Should keep roughly 500/2500 * 0.9 = 18% of packets → ~180 of 1000.
+	remaining := len(store.packets)
+	if remaining > 250 {
+		t.Fatalf("expected most packets evicted (heap 5x over), but %d of 1000 remain", remaining)
+	}
+}
+
 func TestEvictStale_CleansNodeIndexes(t *testing.T) {
 	now := time.Now().UTC()
 	store := makeTestStore(10, now.Add(-48*time.Hour), 0)
@@ -250,3 +276,29 @@ func TestNewPacketStoreNilConfig(t *testing.T) {
 		t.Fatalf("expected retentionHours=0, got %f", store.retentionHours)
 	}
 }
+
+func TestCacheTTLFromConfig(t *testing.T) {
+	// With config values: analyticsHashSizes and analyticsRF should override defaults.
+	cacheTTL := map[string]interface{}{
+		"analyticsHashSizes": float64(7200),
+		"analyticsRF":        float64(300),
+	}
+	store := NewPacketStore(nil, nil, cacheTTL)
+	if store.collisionCacheTTL != 7200*time.Second {
+		t.Fatalf("expected collisionCacheTTL=7200s, got %v", store.collisionCacheTTL)
+	}
+	if store.rfCacheTTL != 300*time.Second {
+		t.Fatalf("expected rfCacheTTL=300s, got %v", store.rfCacheTTL)
+	}
+}
+
+func TestCacheTTLDefaults(t *testing.T) {
+	// Without config, defaults should apply.
+	store := NewPacketStore(nil, nil)
+	if store.collisionCacheTTL != 3600*time.Second {
+		t.Fatalf("expected default collisionCacheTTL=3600s, got %v", store.collisionCacheTTL)
+	}
+	if store.rfCacheTTL != 15*time.Second {
+		t.Fatalf("expected default rfCacheTTL=15s, got %v", store.rfCacheTTL)
+	}
+}

cmd/server/go.mod

@@ -6,11 +6,14 @@ require (
 	github.com/gorilla/mux v1.8.1
 	github.com/gorilla/websocket v1.5.3
 	github.com/meshcore-analyzer/geofilter v0.0.0
+	github.com/meshcore-analyzer/sigvalidate v0.0.0-00010101000000-000000000000
 	modernc.org/sqlite v1.34.5
 )
 
 replace github.com/meshcore-analyzer/geofilter => ../../internal/geofilter
 
+replace github.com/meshcore-analyzer/sigvalidate => ../../internal/sigvalidate
+
 require (
 	github.com/dustin/go-humanize v1.0.1 // indirect
 	github.com/google/uuid v1.6.0 // indirect

cmd/server/helpers_test.go

@@ -2,6 +2,8 @@ package main
 
 import (
 	"encoding/json"
+	"fmt"
+	"math/rand"
 	"net/http"
 	"net/http/httptest"
 	"os"
@@ -220,6 +222,44 @@ func TestSortedCopy(t *testing.T) {
 	}
 }
 
+func TestSortedCopyLarge(t *testing.T) {
+	// Regression: verify correct sort on larger input
+	rng := rand.New(rand.NewSource(42))
+	n := 1000
+	input := make([]float64, n)
+	for i := range input {
+		input[i] = rng.Float64() * 1000
+	}
+	result := sortedCopy(input)
+	if len(result) != n {
+		t.Fatalf("expected %d elements, got %d", n, len(result))
+	}
+	for i := 1; i < len(result); i++ {
+		if result[i] < result[i-1] {
+			t.Fatalf("not sorted at index %d: %v > %v", i, result[i-1], result[i])
+		}
+	}
+	// Original unchanged
+	if input[0] == result[0] && input[1] == result[1] && input[2] == result[2] {
+		// Could be coincidence but very unlikely with random data
+	}
+}
+
+func BenchmarkSortedCopy(b *testing.B) {
+	rng := rand.New(rand.NewSource(42))
+	for _, size := range []int{256, 1000, 10000} {
+		data := make([]float64, size)
+		for i := range data {
+			data[i] = rng.Float64() * 1000
+		}
+		b.Run(fmt.Sprintf("n=%d", size), func(b *testing.B) {
+			for i := 0; i < b.N; i++ {
+				sortedCopy(data)
+			}
+		})
+	}
+}
+
 func TestLastN(t *testing.T) {
 	arr := []map[string]interface{}{
 		{"id": 1}, {"id": 2}, {"id": 3}, {"id": 4}, {"id": 5},

cmd/server/main.go

@@ -104,6 +104,8 @@ func main() {
 	}
 	if cfg.APIKey == "" {
 		log.Printf("[security] WARNING: no apiKey configured — write endpoints are BLOCKED (set apiKey in config.json to enable them)")
+	} else if IsWeakAPIKey(cfg.APIKey) {
+		log.Printf("[security] WARNING: API key is weak or a known default — write endpoints are vulnerable")
 	}
 
 	// Resolve DB path
@@ -139,11 +141,87 @@ func main() {
 	}
 
 	// In-memory packet store
-	store := NewPacketStore(database, cfg.PacketStore)
+	store := NewPacketStore(database, cfg.PacketStore, cfg.CacheTTL)
 	if err := store.Load(); err != nil {
 		log.Fatalf("[store] failed to load: %v", err)
 	}
 
+	// Initialize persisted neighbor graph
+	dbPath = database.path
+	if err := ensureNeighborEdgesTable(dbPath); err != nil {
+		log.Printf("[neighbor] warning: could not create neighbor_edges table: %v", err)
+	}
+	// Add resolved_path column if missing.
+	// NOTE on startup ordering (review item #10): ensureResolvedPathColumn runs AFTER
+	// OpenDB/detectSchema, so db.hasResolvedPath will be false on first run with a
+	// pre-existing DB. This means Load() won't SELECT resolved_path from SQLite.
+	// Async backfill runs after HTTP starts (see backfillResolvedPathsAsync below)
+	// AND to SQLite. On next restart, detectSchema finds the column and Load() reads it.
+	if err := ensureResolvedPathColumn(dbPath); err != nil {
+		log.Printf("[store] warning: could not add resolved_path column: %v", err)
+	} else {
+		database.hasResolvedPath = true // detectSchema ran before column was added; fix the flag
+	}
+
+	// Load or build neighbor graph
+	if neighborEdgesTableExists(database.conn) {
+		store.graph = loadNeighborEdgesFromDB(database.conn)
+		log.Printf("[neighbor] loaded persisted neighbor graph")
+	} else {
+		log.Printf("[neighbor] no persisted edges found, will build in background...")
+		store.graph = NewNeighborGraph() // empty graph — gets populated by background goroutine
+		go func() {
+			defer func() {
+				if r := recover(); r != nil {
+					log.Printf("[neighbor] graph build panic recovered: %v", r)
+				}
+			}()
+			rw, rwErr := openRW(dbPath)
+			if rwErr == nil {
+				edgeCount := buildAndPersistEdges(store, rw)
+				rw.Close()
+				log.Printf("[neighbor] persisted %d edges", edgeCount)
+			}
+			built := BuildFromStore(store)
+			store.mu.Lock()
+			store.graph = built
+			store.mu.Unlock()
+			log.Printf("[neighbor] graph build complete")
+		}()
+	}
+
+	// Initial pickBestObservation runs in background — doesn't need to block HTTP.
+	// API serves best-effort data until this completes (~10s for 100K txs).
+	// Processes in chunks of 5000, releasing the lock between chunks so API
+	// handlers remain responsive.
+	go func() {
+		defer func() {
+			if r := recover(); r != nil {
+				log.Printf("[store] pickBestObservation panic recovered: %v", r)
+			}
+		}()
+		const chunkSize = 5000
+		store.mu.RLock()
+		totalPackets := len(store.packets)
+		store.mu.RUnlock()
+
+		for i := 0; i < totalPackets; i += chunkSize {
+			end := i + chunkSize
+			if end > totalPackets {
+				end = totalPackets
+			}
+			store.mu.Lock()
+			for j := i; j < end && j < len(store.packets); j++ {
+				pickBestObservation(store.packets[j])
+			}
+			store.mu.Unlock()
+			if end < totalPackets {
+				time.Sleep(10 * time.Millisecond) // yield to API handlers
+			}
+		}
+		log.Printf("[store] initial pickBestObservation complete (%d transmissions)", totalPackets)
+	}()
+
 	// WebSocket hub
 	hub := NewHub()
 
@@ -180,26 +258,109 @@ func main() {
 	defer stopEviction()
 
 	// Auto-prune old packets if retention.packetDays is configured
+	var stopPrune func()
 	if cfg.Retention != nil && cfg.Retention.PacketDays > 0 {
 		days := cfg.Retention.PacketDays
+		pruneTicker := time.NewTicker(24 * time.Hour)
+		pruneDone := make(chan struct{})
+		stopPrune = func() {
+			pruneTicker.Stop()
+			close(pruneDone)
+		}
 		go func() {
+			defer func() {
+				if r := recover(); r != nil {
+					log.Printf("[prune] panic recovered: %v", r)
+				}
+			}()
 			time.Sleep(1 * time.Minute)
 			if n, err := database.PruneOldPackets(days); err != nil {
 				log.Printf("[prune] error: %v", err)
 			} else {
 				log.Printf("[prune] deleted %d transmissions older than %d days", n, days)
 			}
-			for range time.Tick(24 * time.Hour) {
-				if n, err := database.PruneOldPackets(days); err != nil {
-					log.Printf("[prune] error: %v", err)
-				} else {
-					log.Printf("[prune] deleted %d transmissions older than %d days", n, days)
+			for {
+				select {
+				case <-pruneTicker.C:
+					if n, err := database.PruneOldPackets(days); err != nil {
+						log.Printf("[prune] error: %v", err)
+					} else {
+						log.Printf("[prune] deleted %d transmissions older than %d days", n, days)
+					}
+				case <-pruneDone:
+					return
 				}
 			}
 		}()
 		log.Printf("[prune] auto-prune enabled: packets older than %d days will be removed daily", days)
 	}
 
+	// Auto-prune old metrics
+	var stopMetricsPrune func()
+	{
+		metricsDays := cfg.MetricsRetentionDays()
+		metricsPruneTicker := time.NewTicker(24 * time.Hour)
+		metricsPruneDone := make(chan struct{})
+		stopMetricsPrune = func() {
+			metricsPruneTicker.Stop()
+			close(metricsPruneDone)
+		}
+		go func() {
+			defer func() {
+				if r := recover(); r != nil {
+					log.Printf("[metrics-prune] panic recovered: %v", r)
+				}
+			}()
+			time.Sleep(2 * time.Minute) // stagger after packet prune
+			database.PruneOldMetrics(metricsDays)
+			for {
+				select {
+				case <-metricsPruneTicker.C:
+					database.PruneOldMetrics(metricsDays)
+				case <-metricsPruneDone:
+					return
+				}
+			}
+		}()
+		log.Printf("[metrics-prune] auto-prune enabled: metrics older than %d days", metricsDays)
+	}
+
+	// Auto-prune old neighbor edges
+	var stopEdgePrune func()
+	{
+		maxAgeDays := cfg.NeighborMaxAgeDays()
+		edgePruneTicker := time.NewTicker(24 * time.Hour)
+		edgePruneDone := make(chan struct{})
+		stopEdgePrune = func() {
+			edgePruneTicker.Stop()
+			close(edgePruneDone)
+		}
+		go func() {
+			defer func() {
+				if r := recover(); r != nil {
+					log.Printf("[neighbor-prune] panic recovered: %v", r)
+				}
+			}()
+			time.Sleep(4 * time.Minute) // stagger after metrics prune
+			store.mu.RLock()
+			g := store.graph
+			store.mu.RUnlock()
+			PruneNeighborEdges(dbPath, g, maxAgeDays)
+			for {
+				select {
+				case <-edgePruneTicker.C:
+					store.mu.RLock()
+					g := store.graph
+					store.mu.RUnlock()
+					PruneNeighborEdges(dbPath, g, maxAgeDays)
+				case <-edgePruneDone:
+					return
+				}
+			}
+		}()
+		log.Printf("[neighbor-prune] auto-prune enabled: edges older than %d days", maxAgeDays)
+	}
+
 	// Graceful shutdown
 	httpServer := &http.Server{
 		Addr:         fmt.Sprintf(":%d", cfg.Port),
@@ -218,6 +379,17 @@ func main() {
 		// 1. Stop accepting new WebSocket/poll data
 		poller.Stop()
 
+		// 1b. Stop auto-prune ticker
+		if stopPrune != nil {
+			stopPrune()
+		}
+		if stopMetricsPrune != nil {
+			stopMetricsPrune()
+		}
+		if stopEdgePrune != nil {
+			stopEdgePrune()
+		}
+
 		// 2. Gracefully drain HTTP connections (up to 15s)
 		ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
 		defer cancel()
@@ -236,6 +408,10 @@ func main() {
 	}()
 
 	log.Printf("[server] CoreScope (Go) listening on http://localhost:%d", cfg.Port)
+
+	// Start async backfill in background — HTTP is now available.
+	go backfillResolvedPathsAsync(store, dbPath, 5000, 100*time.Millisecond, cfg.BackfillHours())
+
 	if err := httpServer.ListenAndServe(); err != http.ErrServerClosed {
 		log.Fatalf("[server] %v", err)
 	}

cmd/server/neighbor_api.go

@@ -0,0 +1,373 @@
+package main
+
+import (
+	"encoding/json"
+	"net/http"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/gorilla/mux"
+)
+
+// ─── Neighbor API response types ───────────────────────────────────────────────
+
+type NeighborResponse struct {
+	Node              string             `json:"node"`
+	Neighbors         []NeighborEntry    `json:"neighbors"`
+	TotalObservations int                `json:"total_observations"`
+}
+
+type NeighborEntry struct {
+	Pubkey      *string          `json:"pubkey"`
+	Prefix      string           `json:"prefix"`
+	Name        *string          `json:"name"`
+	Role        *string          `json:"role"`
+	Count       int              `json:"count"`
+	Score       float64          `json:"score"`
+	FirstSeen   string           `json:"first_seen"`
+	LastSeen    string           `json:"last_seen"`
+	AvgSNR      *float64         `json:"avg_snr"`
+	DistanceKm  *float64         `json:"distance_km,omitempty"`
+	Observers   []string         `json:"observers"`
+	Ambiguous   bool             `json:"ambiguous"`
+	Unresolved  bool             `json:"unresolved,omitempty"`
+	Candidates  []CandidateEntry `json:"candidates,omitempty"`
+}
+
+type CandidateEntry struct {
+	Pubkey string  `json:"pubkey"`
+	Name   string  `json:"name"`
+	Role   string  `json:"role"`
+}
+
+type NeighborGraphResponse struct {
+	Nodes []GraphNode `json:"nodes"`
+	Edges []GraphEdge `json:"edges"`
+	Stats GraphStats  `json:"stats"`
+}
+
+type GraphNode struct {
+	Pubkey        string `json:"pubkey"`
+	Name          string `json:"name"`
+	Role          string `json:"role"`
+	NeighborCount int    `json:"neighbor_count"`
+}
+
+type GraphEdge struct {
+	Source        string   `json:"source"`
+	Target        string   `json:"target"`
+	Weight        int      `json:"weight"`
+	Score         float64  `json:"score"`
+	Bidirectional bool     `json:"bidirectional"`
+	AvgSNR        *float64 `json:"avg_snr"`
+	Ambiguous     bool     `json:"ambiguous"`
+}
+
+type GraphStats struct {
+	TotalNodes     int     `json:"total_nodes"`
+	TotalEdges     int     `json:"total_edges"`
+	AmbiguousEdges int     `json:"ambiguous_edges"`
+	AvgClusterSize float64 `json:"avg_cluster_size"`
+}
+
+// ─── Graph accessor on Server ──────────────────────────────────────────────────
+
+// getNeighborGraph returns the current neighbor graph, rebuilding if stale.
+func (s *Server) getNeighborGraph() *NeighborGraph {
+	s.neighborMu.Lock()
+	defer s.neighborMu.Unlock()
+
+	if s.neighborGraph == nil || s.neighborGraph.IsStale() {
+		if s.store != nil {
+			debugLog := s.cfg != nil && s.cfg.DebugAffinity
+			s.neighborGraph = BuildFromStoreWithLog(s.store, debugLog)
+		} else {
+			s.neighborGraph = NewNeighborGraph()
+		}
+	}
+	return s.neighborGraph
+}
+
+// ─── Handlers ──────────────────────────────────────────────────────────────────
+
+func (s *Server) handleNodeNeighbors(w http.ResponseWriter, r *http.Request) {
+	pubkey := strings.ToLower(mux.Vars(r)["pubkey"])
+
+	minCount := 1
+	if v := r.URL.Query().Get("min_count"); v != "" {
+		if n, err := strconv.Atoi(v); err == nil && n > 0 {
+			minCount = n
+		}
+	}
+	minScore := 0.0
+	if v := r.URL.Query().Get("min_score"); v != "" {
+		if f, err := strconv.ParseFloat(v, 64); err == nil {
+			minScore = f
+		}
+	}
+	includeAmbiguous := true
+	if v := r.URL.Query().Get("include_ambiguous"); v == "false" {
+		includeAmbiguous = false
+	}
+
+	graph := s.getNeighborGraph()
+	edges := graph.Neighbors(pubkey)
+	now := time.Now()
+
+	// Build node info lookup for names/roles/coordinates.
+	nodeMap := s.buildNodeInfoMap()
+
+	// Look up the queried node's GPS coordinates for distance computation.
+	var srcInfo nodeInfo
+	if nodeMap != nil {
+		srcInfo = nodeMap[pubkey]
+	}
+
+	var entries []NeighborEntry
+	totalObs := 0
+
+	for _, e := range edges {
+		score := e.Score(now)
+		if e.Count < minCount || score < minScore {
+			continue
+		}
+		if e.Ambiguous && !includeAmbiguous {
+			continue
+		}
+
+		totalObs += e.Count
+
+		// Determine the "other" node (neighbor of the queried pubkey).
+		neighborPK := e.NodeA
+		if strings.EqualFold(neighborPK, pubkey) {
+			neighborPK = e.NodeB
+		}
+
+		entry := NeighborEntry{
+			Prefix:    e.Prefix,
+			Count:     e.Count,
+			Score:     score,
+			FirstSeen: e.FirstSeen.UTC().Format(time.RFC3339),
+			LastSeen:  e.LastSeen.UTC().Format(time.RFC3339),
+			Ambiguous: e.Ambiguous,
+			Observers: observerList(e.Observers),
+		}
+
+		if e.SNRCount > 0 {
+			avg := e.AvgSNR()
+			entry.AvgSNR = &avg
+		}
+
+		if e.Ambiguous {
+			if len(e.Candidates) == 0 {
+				entry.Unresolved = true
+			}
+			for _, cpk := range e.Candidates {
+				ce := CandidateEntry{Pubkey: cpk}
+				if info, ok := nodeMap[strings.ToLower(cpk)]; ok {
+					ce.Name = info.Name
+					ce.Role = info.Role
+				}
+				entry.Candidates = append(entry.Candidates, ce)
+			}
+		} else if neighborPK != "" {
+			entry.Pubkey = &neighborPK
+			if info, ok := nodeMap[strings.ToLower(neighborPK)]; ok {
+				entry.Name = &info.Name
+				entry.Role = &info.Role
+				if srcInfo.HasGPS && info.HasGPS {
+					d := haversineKm(srcInfo.Lat, srcInfo.Lon, info.Lat, info.Lon)
+					entry.DistanceKm = &d
+				}
+			}
+		}
+
+		entries = append(entries, entry)
+	}
+
+	// Sort by score descending.
+	sort.Slice(entries, func(i, j int) bool {
+		return entries[i].Score > entries[j].Score
+	})
+
+	if entries == nil {
+		entries = []NeighborEntry{}
+	}
+
+	resp := NeighborResponse{
+		Node:              pubkey,
+		Neighbors:         entries,
+		TotalObservations: totalObs,
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(resp)
+}
+
+func (s *Server) handleNeighborGraph(w http.ResponseWriter, r *http.Request) {
+	minCount := 5
+	if v := r.URL.Query().Get("min_count"); v != "" {
+		if n, err := strconv.Atoi(v); err == nil && n > 0 {
+			minCount = n
+		}
+	}
+	minScore := 0.1
+	if v := r.URL.Query().Get("min_score"); v != "" {
+		if f, err := strconv.ParseFloat(v, 64); err == nil {
+			minScore = f
+		}
+	}
+	region := r.URL.Query().Get("region")
+	roleFilter := strings.ToLower(r.URL.Query().Get("role"))
+
+	graph := s.getNeighborGraph()
+	allEdges := graph.AllEdges()
+	now := time.Now()
+
+	// Resolve region observers if filtering.
+	var regionObs map[string]bool
+	if region != "" && s.store != nil {
+		regionObs = s.store.resolveRegionObservers(region)
+	}
+
+	nodeMap := s.buildNodeInfoMap()
+	nodeSet := make(map[string]bool)
+	var filteredEdges []GraphEdge
+	ambiguousCount := 0
+
+	for _, e := range allEdges {
+		score := e.Score(now)
+		if e.Count < minCount || score < minScore {
+			continue
+		}
+
+		// Role filter: at least one endpoint must match the role.
+		if roleFilter != "" && nodeMap != nil {
+			aInfo, aOK := nodeMap[strings.ToLower(e.NodeA)]
+			bInfo, bOK := nodeMap[strings.ToLower(e.NodeB)]
+			aMatch := aOK && strings.EqualFold(aInfo.Role, roleFilter)
+			bMatch := bOK && strings.EqualFold(bInfo.Role, roleFilter)
+			if !aMatch && !bMatch {
+				continue
+			}
+		}
+
+		// Region filter: at least one observer must be in the region.
+		if regionObs != nil {
+			match := false
+			for obs := range e.Observers {
+				if regionObs[obs] {
+					match = true
+					break
+				}
+			}
+			if !match {
+				continue
+			}
+		}
+
+		ge := GraphEdge{
+			Source:        e.NodeA,
+			Target:        e.NodeB,
+			Weight:        e.Count,
+			Score:         score,
+			Bidirectional: true,
+			Ambiguous:     e.Ambiguous,
+		}
+		if e.SNRCount > 0 {
+			avg := e.AvgSNR()
+			ge.AvgSNR = &avg
+		}
+
+		if e.Ambiguous {
+			ambiguousCount++
+			// For ambiguous edges, use prefix as target.
+			if e.NodeB == "" {
+				ge.Target = "prefix:" + e.Prefix
+			}
+		}
+
+		filteredEdges = append(filteredEdges, ge)
+
+		// Track nodes.
+		if e.NodeA != "" && !strings.HasPrefix(e.NodeA, "prefix:") {
+			nodeSet[e.NodeA] = true
+		}
+		if e.NodeB != "" && !strings.HasPrefix(e.NodeB, "prefix:") {
+			nodeSet[e.NodeB] = true
+		}
+	}
+
+	// Build node list.
+	// Count neighbors per node from filtered edges.
+	neighborCounts := make(map[string]int)
+	for _, ge := range filteredEdges {
+		neighborCounts[ge.Source]++
+		neighborCounts[ge.Target]++
+	}
+
+	var nodes []GraphNode
+	for pk := range nodeSet {
+		gn := GraphNode{Pubkey: pk, NeighborCount: neighborCounts[pk]}
+		if info, ok := nodeMap[strings.ToLower(pk)]; ok {
+			gn.Name = info.Name
+			gn.Role = info.Role
+		}
+		nodes = append(nodes, gn)
+	}
+
+	if filteredEdges == nil {
+		filteredEdges = []GraphEdge{}
+	}
+	if nodes == nil {
+		nodes = []GraphNode{}
+	}
+
+	avgCluster := 0.0
+	if len(nodes) > 0 {
+		avgCluster = float64(len(filteredEdges)*2) / float64(len(nodes))
+	}
+
+	resp := NeighborGraphResponse{
+		Nodes: nodes,
+		Edges: filteredEdges,
+		Stats: GraphStats{
+			TotalNodes:     len(nodes),
+			TotalEdges:     len(filteredEdges),
+			AmbiguousEdges: ambiguousCount,
+			AvgClusterSize: avgCluster,
+		},
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(resp)
+}
+
+// ─── Helpers ───────────────────────────────────────────────────────────────────
+
+func observerList(m map[string]bool) []string {
+	if len(m) == 0 {
+		return []string{}
+	}
+	out := make([]string, 0, len(m))
+	for k := range m {
+		out = append(out, k)
+	}
+	sort.Strings(out)
+	return out
+}
+
+// buildNodeInfoMap returns a map of lowercase pubkey → nodeInfo for name/role lookups.
+func (s *Server) buildNodeInfoMap() map[string]nodeInfo {
+	if s.store == nil {
+		return nil
+	}
+	nodes, _ := s.store.getCachedNodesAndPM()
+	m := make(map[string]nodeInfo, len(nodes))
+	for _, n := range nodes {
+		m[strings.ToLower(n.PublicKey)] = n
+	}
+	return m
+}

cmd/server/neighbor_api_test.go

@@ -0,0 +1,459 @@
+package main
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+	"time"
+
+	"github.com/gorilla/mux"
+)
+
+// ─── Helpers ───────────────────────────────────────────────────────────────────
+
+// makeTestServer creates a Server with a pre-built neighbor graph for testing.
+func makeTestServer(graph *NeighborGraph) *Server {
+	srv := &Server{
+		perfStats: NewPerfStats(),
+	}
+	srv.neighborGraph = graph
+	return srv
+}
+
+// makeTestGraph creates a graph with given edges for testing.
+func makeTestGraph(edges ...*NeighborEdge) *NeighborGraph {
+	g := NewNeighborGraph()
+	g.mu.Lock()
+	for _, e := range edges {
+		key := makeEdgeKey(e.NodeA, e.NodeB)
+		if e.NodeB == "" {
+			key = makeEdgeKey(e.NodeA, "prefix:"+e.Prefix)
+		}
+		e.NodeA = key.A
+		if e.NodeB != "" {
+			e.NodeB = key.B
+		}
+		g.edges[key] = e
+		g.byNode[key.A] = append(g.byNode[key.A], e)
+		if key.B != "" && key.B != key.A {
+			g.byNode[key.B] = append(g.byNode[key.B], e)
+		}
+	}
+	g.builtAt = time.Now()
+	g.mu.Unlock()
+	return g
+}
+
+func newEdge(a, b, prefix string, count int, lastSeen time.Time) *NeighborEdge {
+	return &NeighborEdge{
+		NodeA:     a,
+		NodeB:     b,
+		Prefix:    prefix,
+		Count:     count,
+		FirstSeen: lastSeen.Add(-24 * time.Hour),
+		LastSeen:  lastSeen,
+		Observers: map[string]bool{"obs1": true},
+		SNRSum:    -8.0,
+		SNRCount:  1,
+	}
+}
+
+func newAmbiguousEdge(knownPK, prefix string, candidates []string, count int, lastSeen time.Time) *NeighborEdge {
+	return &NeighborEdge{
+		NodeA:      knownPK,
+		NodeB:      "",
+		Prefix:     prefix,
+		Count:      count,
+		FirstSeen:  lastSeen.Add(-24 * time.Hour),
+		LastSeen:   lastSeen,
+		Observers:  map[string]bool{"obs1": true},
+		Ambiguous:  true,
+		Candidates: candidates,
+	}
+}
+
+func serveRequest(srv *Server, method, path string) *httptest.ResponseRecorder {
+	router := mux.NewRouter()
+	router.HandleFunc("/api/nodes/{pubkey}/neighbors", srv.handleNodeNeighbors).Methods("GET")
+	router.HandleFunc("/api/analytics/neighbor-graph", srv.handleNeighborGraph).Methods("GET")
+
+	req := httptest.NewRequest(method, path, nil)
+	rr := httptest.NewRecorder()
+	router.ServeHTTP(rr, req)
+	return rr
+}
+
+// ─── Tests: /api/nodes/{pubkey}/neighbors ──────────────────────────────────────
+
+func TestNeighborAPI_EmptyGraph(t *testing.T) {
+	srv := makeTestServer(makeTestGraph())
+	rr := serveRequest(srv, "GET", "/api/nodes/deadbeef/neighbors")
+
+	if rr.Code != http.StatusOK {
+		t.Fatalf("expected 200, got %d", rr.Code)
+	}
+
+	var resp NeighborResponse
+	if err := json.Unmarshal(rr.Body.Bytes(), &resp); err != nil {
+		t.Fatalf("bad JSON: %v", err)
+	}
+	if resp.Node != "deadbeef" {
+		t.Errorf("node = %q, want deadbeef", resp.Node)
+	}
+	if len(resp.Neighbors) != 0 {
+		t.Errorf("expected 0 neighbors, got %d", len(resp.Neighbors))
+	}
+	if resp.TotalObservations != 0 {
+		t.Errorf("expected 0 observations, got %d", resp.TotalObservations)
+	}
+}
+
+func TestNeighborAPI_SingleNeighbor(t *testing.T) {
+	now := time.Now()
+	e := newEdge("aaaa", "bbbb", "bb", 50, now)
+	srv := makeTestServer(makeTestGraph(e))
+
+	rr := serveRequest(srv, "GET", "/api/nodes/aaaa/neighbors")
+	if rr.Code != http.StatusOK {
+		t.Fatalf("expected 200, got %d", rr.Code)
+	}
+
+	var resp NeighborResponse
+	json.Unmarshal(rr.Body.Bytes(), &resp)
+
+	if len(resp.Neighbors) != 1 {
+		t.Fatalf("expected 1 neighbor, got %d", len(resp.Neighbors))
+	}
+	n := resp.Neighbors[0]
+	if n.Pubkey == nil || *n.Pubkey != "bbbb" {
+		t.Errorf("expected pubkey bbbb, got %v", n.Pubkey)
+	}
+	if n.Count != 50 {
+		t.Errorf("expected count 50, got %d", n.Count)
+	}
+	if n.Score <= 0 {
+		t.Errorf("expected positive score, got %f", n.Score)
+	}
+	if n.Ambiguous {
+		t.Error("expected not ambiguous")
+	}
+}
+
+func TestNeighborAPI_MultipleNeighbors(t *testing.T) {
+	now := time.Now()
+	e1 := newEdge("aaaa", "bbbb", "bb", 100, now)
+	e2 := newEdge("aaaa", "cccc", "cc", 10, now)
+	srv := makeTestServer(makeTestGraph(e1, e2))
+
+	rr := serveRequest(srv, "GET", "/api/nodes/aaaa/neighbors")
+	var resp NeighborResponse
+	json.Unmarshal(rr.Body.Bytes(), &resp)
+
+	if len(resp.Neighbors) != 2 {
+		t.Fatalf("expected 2 neighbors, got %d", len(resp.Neighbors))
+	}
+	// Should be sorted by score descending.
+	if resp.Neighbors[0].Score < resp.Neighbors[1].Score {
+		t.Error("expected sorted by score descending")
+	}
+	if resp.TotalObservations != 110 {
+		t.Errorf("expected 110 total observations, got %d", resp.TotalObservations)
+	}
+}
+
+func TestNeighborAPI_AmbiguousCandidates(t *testing.T) {
+	now := time.Now()
+	e := newAmbiguousEdge("aaaa", "c0", []string{"c0de01", "c0de02"}, 12, now)
+	srv := makeTestServer(makeTestGraph(e))
+
+	rr := serveRequest(srv, "GET", "/api/nodes/aaaa/neighbors")
+	var resp NeighborResponse
+	json.Unmarshal(rr.Body.Bytes(), &resp)
+
+	if len(resp.Neighbors) != 1 {
+		t.Fatalf("expected 1 neighbor, got %d", len(resp.Neighbors))
+	}
+	n := resp.Neighbors[0]
+	if !n.Ambiguous {
+		t.Error("expected ambiguous")
+	}
+	if n.Pubkey != nil {
+		t.Errorf("expected nil pubkey for ambiguous, got %v", n.Pubkey)
+	}
+	if len(n.Candidates) != 2 {
+		t.Fatalf("expected 2 candidates, got %d", len(n.Candidates))
+	}
+}
+
+func TestNeighborAPI_UnresolvedPrefix(t *testing.T) {
+	now := time.Now()
+	e := newAmbiguousEdge("aaaa", "ff", []string{}, 3, now)
+	srv := makeTestServer(makeTestGraph(e))
+
+	rr := serveRequest(srv, "GET", "/api/nodes/aaaa/neighbors")
+	var resp NeighborResponse
+	json.Unmarshal(rr.Body.Bytes(), &resp)
+
+	if len(resp.Neighbors) != 1 {
+		t.Fatalf("expected 1 neighbor, got %d", len(resp.Neighbors))
+	}
+	n := resp.Neighbors[0]
+	if !n.Unresolved {
+		t.Error("expected unresolved=true")
+	}
+	if len(n.Candidates) != 0 {
+		t.Error("expected empty candidates for unresolved")
+	}
+}
+
+func TestNeighborAPI_MinCountFilter(t *testing.T) {
+	now := time.Now()
+	e1 := newEdge("aaaa", "bbbb", "bb", 100, now)
+	e2 := newEdge("aaaa", "cccc", "cc", 2, now)
+	srv := makeTestServer(makeTestGraph(e1, e2))
+
+	rr := serveRequest(srv, "GET", "/api/nodes/aaaa/neighbors?min_count=10")
+	var resp NeighborResponse
+	json.Unmarshal(rr.Body.Bytes(), &resp)
+
+	if len(resp.Neighbors) != 1 {
+		t.Fatalf("expected 1 neighbor after min_count filter, got %d", len(resp.Neighbors))
+	}
+	if *resp.Neighbors[0].Pubkey != "bbbb" {
+		t.Error("expected bbbb to survive filter")
+	}
+}
+
+func TestNeighborAPI_MinScoreFilter(t *testing.T) {
+	now := time.Now()
+	e1 := newEdge("aaaa", "bbbb", "bb", 100, now)                               // score ~1.0
+	e2 := newEdge("aaaa", "cccc", "cc", 1, now.Add(-30*24*time.Hour)) // very low score
+	srv := makeTestServer(makeTestGraph(e1, e2))
+
+	rr := serveRequest(srv, "GET", "/api/nodes/aaaa/neighbors?min_score=0.5")
+	var resp NeighborResponse
+	json.Unmarshal(rr.Body.Bytes(), &resp)
+
+	if len(resp.Neighbors) != 1 {
+		t.Fatalf("expected 1 neighbor after min_score filter, got %d", len(resp.Neighbors))
+	}
+}
+
+func TestNeighborAPI_ExcludeAmbiguous(t *testing.T) {
+	now := time.Now()
+	e1 := newEdge("aaaa", "bbbb", "bb", 50, now)
+	e2 := newAmbiguousEdge("aaaa", "c0", []string{"c0de01"}, 10, now)
+	srv := makeTestServer(makeTestGraph(e1, e2))
+
+	rr := serveRequest(srv, "GET", "/api/nodes/aaaa/neighbors?include_ambiguous=false")
+	var resp NeighborResponse
+	json.Unmarshal(rr.Body.Bytes(), &resp)
+
+	if len(resp.Neighbors) != 1 {
+		t.Fatalf("expected 1 non-ambiguous neighbor, got %d", len(resp.Neighbors))
+	}
+}
+
+func TestNeighborAPI_UnknownNode(t *testing.T) {
+	now := time.Now()
+	e := newEdge("aaaa", "bbbb", "bb", 50, now)
+	srv := makeTestServer(makeTestGraph(e))
+
+	rr := serveRequest(srv, "GET", "/api/nodes/unknown1234/neighbors")
+	if rr.Code != http.StatusOK {
+		t.Fatalf("expected 200 for unknown node, got %d", rr.Code)
+	}
+
+	var resp NeighborResponse
+	json.Unmarshal(rr.Body.Bytes(), &resp)
+	if len(resp.Neighbors) != 0 {
+		t.Errorf("expected 0 neighbors for unknown node, got %d", len(resp.Neighbors))
+	}
+}
+
+// ─── Tests: /api/analytics/neighbor-graph ──────────────────────────────────────
+
+func TestNeighborGraphAPI_EmptyGraph(t *testing.T) {
+	srv := makeTestServer(makeTestGraph())
+	rr := serveRequest(srv, "GET", "/api/analytics/neighbor-graph")
+
+	if rr.Code != http.StatusOK {
+		t.Fatalf("expected 200, got %d", rr.Code)
+	}
+
+	var resp NeighborGraphResponse
+	json.Unmarshal(rr.Body.Bytes(), &resp)
+
+	if len(resp.Edges) != 0 {
+		t.Errorf("expected 0 edges, got %d", len(resp.Edges))
+	}
+	if resp.Stats.TotalEdges != 0 {
+		t.Errorf("expected 0 total edges, got %d", resp.Stats.TotalEdges)
+	}
+	if resp.Stats.TotalNodes != 0 {
+		t.Errorf("expected 0 total nodes, got %d", resp.Stats.TotalNodes)
+	}
+}
+
+func TestNeighborGraphAPI_WithEdges(t *testing.T) {
+	now := time.Now()
+	e1 := newEdge("aaaa", "bbbb", "bb", 100, now)
+	e2 := newEdge("bbbb", "cccc", "cc", 50, now)
+	srv := makeTestServer(makeTestGraph(e1, e2))
+
+	rr := serveRequest(srv, "GET", "/api/analytics/neighbor-graph?min_count=1&min_score=0")
+	var resp NeighborGraphResponse
+	json.Unmarshal(rr.Body.Bytes(), &resp)
+
+	if len(resp.Edges) != 2 {
+		t.Fatalf("expected 2 edges, got %d", len(resp.Edges))
+	}
+	if resp.Stats.TotalNodes != 3 {
+		t.Errorf("expected 3 nodes, got %d", resp.Stats.TotalNodes)
+	}
+	if resp.Stats.TotalEdges != 2 {
+		t.Errorf("expected 2 total edges, got %d", resp.Stats.TotalEdges)
+	}
+}
+
+func TestNeighborGraphAPI_MinCountDefault(t *testing.T) {
+	now := time.Now()
+	e1 := newEdge("aaaa", "bbbb", "bb", 100, now) // passes default min_count=5
+	e2 := newEdge("aaaa", "cccc", "cc", 2, now)   // fails default min_count=5
+	srv := makeTestServer(makeTestGraph(e1, e2))
+
+	rr := serveRequest(srv, "GET", "/api/analytics/neighbor-graph")
+	var resp NeighborGraphResponse
+	json.Unmarshal(rr.Body.Bytes(), &resp)
+
+	if len(resp.Edges) != 1 {
+		t.Fatalf("expected 1 edge with default min_count=5, got %d", len(resp.Edges))
+	}
+}
+
+func TestNeighborGraphAPI_AmbiguousEdgesCount(t *testing.T) {
+	now := time.Now()
+	e1 := newEdge("aaaa", "bbbb", "bb", 100, now)
+	e2 := newAmbiguousEdge("aaaa", "c0", []string{"c0de01", "c0de02"}, 50, now)
+	srv := makeTestServer(makeTestGraph(e1, e2))
+
+	rr := serveRequest(srv, "GET", "/api/analytics/neighbor-graph?min_count=1&min_score=0")
+	var resp NeighborGraphResponse
+	json.Unmarshal(rr.Body.Bytes(), &resp)
+
+	if resp.Stats.AmbiguousEdges != 1 {
+		t.Errorf("expected 1 ambiguous edge, got %d", resp.Stats.AmbiguousEdges)
+	}
+}
+
+func TestNeighborAPI_DistanceKm_WithGPS(t *testing.T) {
+	db := setupTestDB(t)
+	defer db.Close()
+
+	db.conn.Exec(`INSERT INTO nodes (public_key, name, role, lat, lon, last_seen, first_seen)
+		VALUES ('aaaa', 'NodeA', 'repeater', 51.5074, -0.1278, '2026-01-01T00:00:00Z', '2025-01-01T00:00:00Z')`)
+	db.conn.Exec(`INSERT INTO nodes (public_key, name, role, lat, lon, last_seen, first_seen)
+		VALUES ('bbbb', 'NodeB', 'repeater', 51.5200, -0.1200, '2026-01-01T00:00:00Z', '2025-01-01T00:00:00Z')`)
+
+	cfg := &Config{Port: 3000}
+	hub := NewHub()
+	srv := NewServer(db, cfg, hub)
+	srv.store = NewPacketStore(db, nil)
+
+	now := time.Now()
+	srv.neighborGraph = makeTestGraph(newEdge("aaaa", "bbbb", "bb", 50, now))
+
+	rr := serveRequest(srv, "GET", "/api/nodes/aaaa/neighbors")
+	var resp NeighborResponse
+	json.Unmarshal(rr.Body.Bytes(), &resp)
+
+	if len(resp.Neighbors) != 1 {
+		t.Fatalf("expected 1 neighbor, got %d", len(resp.Neighbors))
+	}
+	n := resp.Neighbors[0]
+	if n.DistanceKm == nil {
+		t.Fatal("expected distance_km to be set for GPS-enabled nodes")
+	}
+	if *n.DistanceKm <= 0 {
+		t.Errorf("expected positive distance, got %f", *n.DistanceKm)
+	}
+}
+
+func TestNeighborAPI_DistanceKm_NoGPS(t *testing.T) {
+	db := setupTestDB(t)
+	defer db.Close()
+
+	// Nodes with 0,0 coords → HasGPS=false
+	db.conn.Exec(`INSERT INTO nodes (public_key, name, role, lat, lon, last_seen, first_seen)
+		VALUES ('aaaa', 'NodeA', 'repeater', 0, 0, '2026-01-01T00:00:00Z', '2025-01-01T00:00:00Z')`)
+	db.conn.Exec(`INSERT INTO nodes (public_key, name, role, lat, lon, last_seen, first_seen)
+		VALUES ('bbbb', 'NodeB', 'repeater', 0, 0, '2026-01-01T00:00:00Z', '2025-01-01T00:00:00Z')`)
+
+	cfg := &Config{Port: 3000}
+	hub := NewHub()
+	srv := NewServer(db, cfg, hub)
+	srv.store = NewPacketStore(db, nil)
+
+	now := time.Now()
+	srv.neighborGraph = makeTestGraph(newEdge("aaaa", "bbbb", "bb", 50, now))
+
+	rr := serveRequest(srv, "GET", "/api/nodes/aaaa/neighbors")
+	var resp NeighborResponse
+	json.Unmarshal(rr.Body.Bytes(), &resp)
+
+	if len(resp.Neighbors) != 1 {
+		t.Fatalf("expected 1 neighbor, got %d", len(resp.Neighbors))
+	}
+	if resp.Neighbors[0].DistanceKm != nil {
+		t.Errorf("expected nil distance_km for nodes without GPS, got %f", *resp.Neighbors[0].DistanceKm)
+	}
+}
+
+func TestNeighborGraphAPI_RegionFilter(t *testing.T) {
+	now := time.Now()
+	// Edge with observer "obs-sjc" — would match region SJC if we had region resolution.
+	// Without a store, region filtering returns nothing (no observers match).
+	e1 := newEdge("aaaa", "bbbb", "bb", 100, now)
+	srv := makeTestServer(makeTestGraph(e1))
+	// No store → region filter has no observers → filters everything out.
+	rr := serveRequest(srv, "GET", "/api/analytics/neighbor-graph?region=SJC&min_count=1&min_score=0")
+	var resp NeighborGraphResponse
+	json.Unmarshal(rr.Body.Bytes(), &resp)
+
+	// With no store, regionObs is nil so filter is skipped → all edges returned.
+	// Actually: region="" when store is nil → regionObs stays nil → no filtering.
+	// Wait, we set region=SJC and store is nil → resolveRegionObservers won't be called
+	// because s.store is nil. So regionObs is nil → filter not applied.
+	// Let's just check it doesn't crash.
+	if rr.Code != http.StatusOK {
+		t.Fatalf("expected 200, got %d", rr.Code)
+	}
+}
+
+func TestNeighborGraphAPI_ResponseShape(t *testing.T) {
+	now := time.Now()
+	e := newEdge("aaaa", "bbbb", "bb", 100, now)
+	srv := makeTestServer(makeTestGraph(e))
+
+	rr := serveRequest(srv, "GET", "/api/analytics/neighbor-graph?min_count=1&min_score=0")
+	var raw map[string]interface{}
+	if err := json.Unmarshal(rr.Body.Bytes(), &raw); err != nil {
+		t.Fatalf("bad JSON: %v", err)
+	}
+
+	// Verify top-level keys.
+	for _, key := range []string{"nodes", "edges", "stats"} {
+		if _, ok := raw[key]; !ok {
+			t.Errorf("missing key %q in response", key)
+		}
+	}
+
+	// Verify stats keys.
+	stats := raw["stats"].(map[string]interface{})
+	for _, key := range []string{"total_nodes", "total_edges", "ambiguous_edges", "avg_cluster_size"} {
+		if _, ok := stats[key]; !ok {
+			t.Errorf("missing stats key %q", key)
+		}
+	}
+}

cmd/server/neighbor_debug.go

@@ -0,0 +1,399 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"math"
+	"net/http"
+	"sort"
+	"strings"
+	"time"
+)
+
+// ─── Debug API response types ──────────────────────────────────────────────────
+
+type DebugAffinityResponse struct {
+	Edges       []DebugEdge       `json:"edges"`
+	Resolutions []DebugResolution `json:"resolutions"`
+	Stats       DebugStats        `json:"stats"`
+}
+
+type DebugEdge struct {
+	NodeA            string   `json:"nodeA"`
+	NodeAName        string   `json:"nodeAName,omitempty"`
+	NodeB            string   `json:"nodeB"`
+	NodeBName        string   `json:"nodeBName,omitempty"`
+	Prefix           string   `json:"prefix"`
+	Weight           int      `json:"weight"`
+	ObservationCount int      `json:"observationCount"`
+	LastSeen         string   `json:"lastSeen"`
+	FirstSeen        string   `json:"firstSeen"`
+	Score            float64  `json:"score"`
+	Jaccard          float64  `json:"jaccard,omitempty"`
+	AvgSNR           *float64 `json:"avgSnr,omitempty"`
+	Observers        []string `json:"observers"`
+	Ambiguous        bool     `json:"ambiguous"`
+	Unresolved       bool     `json:"unresolved,omitempty"`
+	Resolved         bool     `json:"resolved,omitempty"`
+}
+
+type DebugResolution struct {
+	Prefix           string             `json:"prefix"`
+	Chosen           string             `json:"chosen,omitempty"`
+	ChosenName       string             `json:"chosenName,omitempty"`
+	ChosenScore      int                `json:"chosenScore"`
+	ChosenJaccard    float64            `json:"chosenJaccard"`
+	Confidence       string             `json:"confidence"`
+	Candidates       []DebugCandidate   `json:"candidates"`
+	Ratio            float64            `json:"ratio"`
+	ThresholdApplied float64            `json:"thresholdApplied"`
+	Method           string             `json:"method"`
+	Tier             string             `json:"tier"`
+	KnownNode        string             `json:"knownNode"`
+	KnownNodeName    string             `json:"knownNodeName,omitempty"`
+}
+
+type DebugCandidate struct {
+	Pubkey  string  `json:"pubkey"`
+	Name    string  `json:"name,omitempty"`
+	Score   int     `json:"score"`
+	Jaccard float64 `json:"jaccard"`
+}
+
+type DebugStats struct {
+	TotalEdges       int     `json:"totalEdges"`
+	TotalNodes       int     `json:"totalNodes"`
+	ResolvedCount    int     `json:"resolvedCount"`
+	AmbiguousCount   int     `json:"ambiguousCount"`
+	UnresolvedCount  int     `json:"unresolvedCount"`
+	AvgConfidence    float64 `json:"avgConfidence"`
+	ColdStartCoverage float64 `json:"coldStartCoverage"`
+	CacheAge         string  `json:"cacheAge"`
+	LastRebuild      string  `json:"lastRebuild"`
+}
+
+// ─── Debug API Handler ─────────────────────────────────────────────────────────
+
+func (s *Server) handleDebugAffinity(w http.ResponseWriter, r *http.Request) {
+	prefixFilter := strings.ToLower(r.URL.Query().Get("prefix"))
+	nodeFilter := strings.ToLower(r.URL.Query().Get("node"))
+
+	graph := s.getNeighborGraph()
+	now := time.Now()
+	nodeMap := s.buildNodeInfoMap()
+
+	allEdges := graph.AllEdges()
+
+	// Build edges response
+	var debugEdges []DebugEdge
+	nodeSet := make(map[string]bool)
+	resolvedCount := 0
+	ambiguousCount := 0
+	unresolvedCount := 0
+	var scoreSum float64
+	var scoreCount int
+
+	for _, e := range allEdges {
+		// Apply filters
+		if prefixFilter != "" && !strings.EqualFold(e.Prefix, prefixFilter) {
+			continue
+		}
+		if nodeFilter != "" {
+			if !strings.EqualFold(e.NodeA, nodeFilter) && !strings.EqualFold(e.NodeB, nodeFilter) {
+				// Also check if any candidate matches
+				found := false
+				for _, c := range e.Candidates {
+					if strings.EqualFold(c, nodeFilter) {
+						found = true
+						break
+					}
+				}
+				if !found {
+					continue
+				}
+			}
+		}
+
+		score := e.Score(now)
+		de := DebugEdge{
+			NodeA:            e.NodeA,
+			NodeB:            e.NodeB,
+			Prefix:           e.Prefix,
+			Weight:           e.Count,
+			ObservationCount: e.Count,
+			LastSeen:         e.LastSeen.UTC().Format(time.RFC3339),
+			FirstSeen:        e.FirstSeen.UTC().Format(time.RFC3339),
+			Score:            math.Round(score*1000) / 1000,
+			Observers:        observerList(e.Observers),
+			Ambiguous:        e.Ambiguous,
+			Resolved:         e.Resolved,
+		}
+
+		if e.SNRCount > 0 {
+			avg := e.AvgSNR()
+			de.AvgSNR = &avg
+		}
+
+		// Add names
+		if nodeMap != nil {
+			if info, ok := nodeMap[strings.ToLower(e.NodeA)]; ok {
+				de.NodeAName = info.Name
+			}
+			if info, ok := nodeMap[strings.ToLower(e.NodeB)]; ok {
+				de.NodeBName = info.Name
+			}
+		}
+
+		if e.Ambiguous {
+			if len(e.Candidates) == 0 {
+				de.Unresolved = true
+				unresolvedCount++
+			} else {
+				ambiguousCount++
+			}
+		} else {
+			resolvedCount++
+			scoreSum += score
+			scoreCount++
+		}
+
+		debugEdges = append(debugEdges, de)
+
+		if e.NodeA != "" && !strings.HasPrefix(e.NodeA, "prefix:") {
+			nodeSet[e.NodeA] = true
+		}
+		if e.NodeB != "" && !strings.HasPrefix(e.NodeB, "prefix:") {
+			nodeSet[e.NodeB] = true
+		}
+	}
+
+	// Build resolutions from the graph's disambiguation history
+	resolutions := s.buildResolutions(graph, nodeMap, prefixFilter, nodeFilter)
+
+	// Cold-start coverage: % of 1-byte prefixes with ≥3 observations
+	coldStart := s.computeColdStartCoverage(allEdges)
+
+	avgConf := 0.0
+	if scoreCount > 0 {
+		avgConf = math.Round(scoreSum/float64(scoreCount)*1000) / 1000
+	}
+
+	if debugEdges == nil {
+		debugEdges = []DebugEdge{}
+	}
+	if resolutions == nil {
+		resolutions = []DebugResolution{}
+	}
+
+	// Sort edges by weight descending
+	sort.Slice(debugEdges, func(i, j int) bool {
+		return debugEdges[i].Weight > debugEdges[j].Weight
+	})
+
+	graph.mu.RLock()
+	builtAt := graph.builtAt
+	graph.mu.RUnlock()
+
+	cacheAge := ""
+	lastRebuild := ""
+	if !builtAt.IsZero() {
+		cacheAge = fmt.Sprintf("%.1fs", time.Since(builtAt).Seconds())
+		lastRebuild = builtAt.UTC().Format(time.RFC3339)
+	}
+
+	resp := DebugAffinityResponse{
+		Edges:       debugEdges,
+		Resolutions: resolutions,
+		Stats: DebugStats{
+			TotalEdges:        len(debugEdges),
+			TotalNodes:        len(nodeSet),
+			ResolvedCount:     resolvedCount,
+			AmbiguousCount:    ambiguousCount,
+			UnresolvedCount:   unresolvedCount,
+			AvgConfidence:     avgConf,
+			ColdStartCoverage: coldStart,
+			CacheAge:          cacheAge,
+			LastRebuild:       lastRebuild,
+		},
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(resp)
+}
+
+// buildResolutions generates per-prefix resolution decision logs.
+// It uses resolveWithContext (M4) to show the actual 4-tier fallback path
+// (affinity → geo → GPS → first_match) for each prefix resolution.
+func (s *Server) buildResolutions(graph *NeighborGraph, nodeMap map[string]nodeInfo, prefixFilter, nodeFilter string) []DebugResolution {
+	graph.mu.RLock()
+	defer graph.mu.RUnlock()
+
+	// Get the prefix map for resolveWithContext tier computation.
+	var pm *prefixMap
+	if s.store != nil {
+		_, pm = s.store.getCachedNodesAndPM()
+	}
+
+	// Build resolved neighbor sets for Jaccard computation
+	resolvedNeighbors := make(map[string]map[string]bool)
+	for _, e := range graph.edges {
+		if e.Ambiguous || e.NodeB == "" {
+			continue
+		}
+		if resolvedNeighbors[e.NodeA] == nil {
+			resolvedNeighbors[e.NodeA] = make(map[string]bool)
+		}
+		if resolvedNeighbors[e.NodeB] == nil {
+			resolvedNeighbors[e.NodeB] = make(map[string]bool)
+		}
+		resolvedNeighbors[e.NodeA][e.NodeB] = true
+		resolvedNeighbors[e.NodeB][e.NodeA] = true
+	}
+
+	var resolutions []DebugResolution
+
+	for _, e := range graph.edges {
+		// Show resolution info for both resolved (auto-resolved) and ambiguous edges
+		if !e.Resolved && !e.Ambiguous {
+			continue
+		}
+		if len(e.Candidates) < 2 && !e.Resolved {
+			continue
+		}
+
+		if prefixFilter != "" && !strings.EqualFold(e.Prefix, prefixFilter) {
+			continue
+		}
+
+		knownNode := e.NodeA
+		if strings.HasPrefix(e.NodeA, "prefix:") {
+			knownNode = e.NodeB
+		}
+
+		if nodeFilter != "" && !strings.EqualFold(knownNode, nodeFilter) {
+			// Check if the resolved node matches
+			if e.Resolved && !strings.EqualFold(e.NodeB, nodeFilter) && !strings.EqualFold(e.NodeA, nodeFilter) {
+				continue
+			}
+		}
+
+		knownNeighbors := resolvedNeighbors[knownNode]
+
+		var candidates []DebugCandidate
+		candList := e.Candidates
+		// For resolved edges, add the resolved node as a candidate too
+		if e.Resolved {
+			resolvedPK := e.NodeB
+			if strings.EqualFold(e.NodeB, knownNode) {
+				resolvedPK = e.NodeA
+			}
+			// Include resolved + original candidates
+			found := false
+			for _, c := range candList {
+				if strings.EqualFold(c, resolvedPK) {
+					found = true
+					break
+				}
+			}
+			if !found {
+				candList = append([]string{resolvedPK}, candList...)
+			}
+		}
+
+		for _, cpk := range candList {
+			candNeighbors := resolvedNeighbors[cpk]
+			j := jaccardSimilarity(knownNeighbors, candNeighbors)
+			dc := DebugCandidate{
+				Pubkey:  cpk,
+				Score:   e.Count,
+				Jaccard: math.Round(j*1000) / 1000,
+			}
+			if nodeMap != nil {
+				if info, ok := nodeMap[strings.ToLower(cpk)]; ok {
+					dc.Name = info.Name
+				}
+			}
+			candidates = append(candidates, dc)
+		}
+
+		// Sort candidates by Jaccard descending
+		sort.Slice(candidates, func(i, j int) bool {
+			return candidates[i].Jaccard > candidates[j].Jaccard
+		})
+
+		dr := DebugResolution{
+			Prefix:           e.Prefix,
+			ThresholdApplied: affinityConfidenceRatio,
+			KnownNode:        knownNode,
+		}
+
+		if nodeMap != nil {
+			if info, ok := nodeMap[strings.ToLower(knownNode)]; ok {
+				dr.KnownNodeName = info.Name
+			}
+		}
+
+		// Use resolveWithContext to determine the actual 4-tier fallback path.
+		tier := ""
+		if pm != nil {
+			contextPubkeys := []string{knownNode}
+			_, tierUsed, _ := pm.resolveWithContext(e.Prefix, contextPubkeys, graph)
+			tier = tierUsed
+		}
+
+		if e.Resolved && len(candidates) > 0 {
+			dr.Chosen = candidates[0].Pubkey
+			dr.ChosenName = candidates[0].Name
+			dr.ChosenScore = candidates[0].Score
+			dr.ChosenJaccard = candidates[0].Jaccard
+			dr.Confidence = "HIGH"
+			dr.Method = "auto-resolved"
+			dr.Tier = tier
+			if len(candidates) > 1 && candidates[1].Jaccard > 0 {
+				dr.Ratio = math.Round(candidates[0].Jaccard/candidates[1].Jaccard*10) / 10
+			} else if candidates[0].Jaccard > 0 {
+				dr.Ratio = 999.0 // effectively infinite — JSON doesn't support Infinity
+			}
+		} else {
+			dr.Confidence = "AMBIGUOUS"
+			dr.Method = "ambiguous"
+			dr.Tier = tier
+			if len(candidates) >= 2 {
+				dr.ChosenScore = candidates[0].Score
+				dr.ChosenJaccard = candidates[0].Jaccard
+				if candidates[1].Jaccard > 0 {
+					dr.Ratio = math.Round(candidates[0].Jaccard/candidates[1].Jaccard*10) / 10
+				}
+			}
+		}
+		dr.Candidates = candidates
+
+		resolutions = append(resolutions, dr)
+	}
+
+	return resolutions
+}
+
+// computeColdStartCoverage returns the % of active 1-byte hex prefixes with ≥3 observations.
+func (s *Server) computeColdStartCoverage(edges []*NeighborEdge) float64 {
+	// Track which 1-byte prefixes have sufficient observations
+	prefixObs := make(map[string]int) // 1-byte prefix → total observations
+	for _, e := range edges {
+		if len(e.Prefix) == 2 { // 1-byte = 2 hex chars
+			prefixObs[strings.ToLower(e.Prefix)] += e.Count
+		}
+	}
+
+	if len(prefixObs) == 0 {
+		return 0
+	}
+
+	covered := 0
+	for _, count := range prefixObs {
+		if count >= affinityMinObservations {
+			covered++
+		}
+	}
+
+	return math.Round(float64(covered)/float64(len(prefixObs))*1000) / 10
+}

cmd/server/neighbor_debug_test.go

@@ -0,0 +1,223 @@
+package main
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestDebugAffinityEndpoint(t *testing.T) {
+	now := time.Now()
+
+	edge1 := newEdge("aaaa1111", "bbbb2222", "bb", 50, now)
+	edge2 := newEdge("aaaa1111", "", "cc", 10, now)
+	edge2.Ambiguous = true
+	edge2.Candidates = []string{"cccc3333", "cccc4444"}
+
+	graph := makeTestGraph(edge1, edge2)
+	srv := makeTestServer(graph)
+	srv.cfg = &Config{APIKey: "test-key", DebugAffinity: true}
+
+	r, _ := http.NewRequest("GET", "/api/debug/affinity", nil)
+	r.Header.Set("X-API-Key", "test-key")
+	w := httptest.NewRecorder()
+	srv.handleDebugAffinity(w, r)
+
+	if w.Code != http.StatusOK {
+		t.Fatalf("expected 200, got %d", w.Code)
+	}
+
+	var resp DebugAffinityResponse
+	if err := json.NewDecoder(w.Body).Decode(&resp); err != nil {
+		t.Fatalf("decode error: %v", err)
+	}
+
+	if len(resp.Edges) != 2 {
+		t.Errorf("expected 2 edges, got %d", len(resp.Edges))
+	}
+
+	// Check stats shape
+	if resp.Stats.TotalEdges != 2 {
+		t.Errorf("expected 2 total edges in stats, got %d", resp.Stats.TotalEdges)
+	}
+	if resp.Stats.LastRebuild == "" {
+		t.Error("expected lastRebuild to be set")
+	}
+	if resp.Stats.CacheAge == "" {
+		t.Error("expected cacheAge to be set")
+	}
+}
+
+func TestDebugAffinityPrefixFilter(t *testing.T) {
+	now := time.Now()
+	edge1 := newEdge("aaaa1111", "bbbb2222", "bb", 50, now)
+	edge2 := newEdge("aaaa1111", "dddd3333", "dd", 30, now)
+
+	graph := makeTestGraph(edge1, edge2)
+	srv := makeTestServer(graph)
+	srv.cfg = &Config{APIKey: "test-key"}
+
+	r, _ := http.NewRequest("GET", "/api/debug/affinity?prefix=bb", nil)
+	r.Header.Set("X-API-Key", "test-key")
+	w := httptest.NewRecorder()
+	srv.handleDebugAffinity(w, r)
+
+	var resp DebugAffinityResponse
+	json.NewDecoder(w.Body).Decode(&resp)
+
+	if len(resp.Edges) != 1 {
+		t.Errorf("expected 1 edge with prefix filter, got %d", len(resp.Edges))
+	}
+}
+
+func TestDebugAffinityNodeFilter(t *testing.T) {
+	now := time.Now()
+	edge1 := newEdge("aaaa1111", "bbbb2222", "bb", 50, now)
+	edge2 := newEdge("cccc3333", "dddd4444", "dd", 30, now)
+
+	graph := makeTestGraph(edge1, edge2)
+	srv := makeTestServer(graph)
+	srv.cfg = &Config{APIKey: "test-key"}
+
+	r, _ := http.NewRequest("GET", "/api/debug/affinity?node=aaaa1111", nil)
+	r.Header.Set("X-API-Key", "test-key")
+	w := httptest.NewRecorder()
+	srv.handleDebugAffinity(w, r)
+
+	var resp DebugAffinityResponse
+	json.NewDecoder(w.Body).Decode(&resp)
+
+	if len(resp.Edges) != 1 {
+		t.Errorf("expected 1 edge with node filter, got %d", len(resp.Edges))
+	}
+}
+
+func TestDebugAffinityRequiresAuth(t *testing.T) {
+	graph := makeTestGraph()
+	srv := makeTestServer(graph)
+	srv.cfg = &Config{APIKey: "secret"}
+
+	r, _ := http.NewRequest("GET", "/api/debug/affinity", nil)
+	r.Header.Set("X-API-Key", "wrong-key")
+	w := httptest.NewRecorder()
+
+	// Use the requireAPIKey middleware
+	handler := srv.requireAPIKey(http.HandlerFunc(srv.handleDebugAffinity))
+	handler.ServeHTTP(w, r)
+
+	if w.Code != http.StatusUnauthorized {
+		t.Errorf("expected 401, got %d", w.Code)
+	}
+}
+
+func TestStructuredLogging(t *testing.T) {
+	// Test that the logging function in the graph actually works
+	var logMessages []string
+	g := NewNeighborGraph()
+	g.logFn = func(prefix, msg string) {
+		logMessages = append(logMessages, "[affinity] resolve "+prefix+": "+msg)
+	}
+
+	// Add some edges that would trigger disambiguation
+	now := time.Now()
+	// Add resolved edges for neighbor sets
+	g.mu.Lock()
+	// Node aaaa has neighbors: xxxx, yyyy
+	e1 := &NeighborEdge{NodeA: "aaaa", NodeB: "xxxx", Prefix: "xx", Count: 10, Observers: map[string]bool{}, FirstSeen: now, LastSeen: now}
+	g.edges[makeEdgeKey("aaaa", "xxxx")] = e1
+	g.byNode["aaaa"] = append(g.byNode["aaaa"], e1)
+	g.byNode["xxxx"] = append(g.byNode["xxxx"], e1)
+
+	e2 := &NeighborEdge{NodeA: "aaaa", NodeB: "yyyy", Prefix: "yy", Count: 10, Observers: map[string]bool{}, FirstSeen: now, LastSeen: now}
+	g.edges[makeEdgeKey("aaaa", "yyyy")] = e2
+	g.byNode["aaaa"] = append(g.byNode["aaaa"], e2)
+	g.byNode["yyyy"] = append(g.byNode["yyyy"], e2)
+
+	// Candidate cccc1 also has neighbor xxxx, yyyy (high Jaccard with aaaa)
+	e3 := &NeighborEdge{NodeA: "cccc1", NodeB: "xxxx", Prefix: "xx", Count: 10, Observers: map[string]bool{}, FirstSeen: now, LastSeen: now}
+	g.edges[makeEdgeKey("cccc1", "xxxx")] = e3
+	g.byNode["cccc1"] = append(g.byNode["cccc1"], e3)
+
+	e4 := &NeighborEdge{NodeA: "cccc1", NodeB: "yyyy", Prefix: "yy", Count: 10, Observers: map[string]bool{}, FirstSeen: now, LastSeen: now}
+	g.edges[makeEdgeKey("cccc1", "yyyy")] = e4
+	g.byNode["cccc1"] = append(g.byNode["cccc1"], e4)
+
+	// Candidate cccc2 has no neighbors (low Jaccard)
+	// Add ambiguous edge: aaaa ↔ prefix:cc with candidates [cccc1, cccc2]
+	ambigEdge := &NeighborEdge{
+		NodeA: "aaaa", NodeB: "", Prefix: "cc", Count: 5,
+		Ambiguous: true, Candidates: []string{"cccc1", "cccc2"},
+		Observers: map[string]bool{}, FirstSeen: now, LastSeen: now,
+	}
+	ambigKey := makeEdgeKey("aaaa", "prefix:cc")
+	g.edges[ambigKey] = ambigEdge
+	g.byNode["aaaa"] = append(g.byNode["aaaa"], ambigEdge)
+	g.mu.Unlock()
+
+	// Now run disambiguate — this should trigger logging
+	g.disambiguate()
+
+	if len(logMessages) == 0 {
+		t.Error("expected at least one log message from disambiguation")
+	}
+
+	found := false
+	for _, msg := range logMessages {
+		if strings.Contains(msg, "[affinity] resolve cc:") {
+			found = true
+		}
+	}
+	if !found {
+		t.Errorf("expected log message about prefix 'cc', got: %v", logMessages)
+	}
+}
+
+func TestColdStartCoverage(t *testing.T) {
+	edges := []*NeighborEdge{
+		{Prefix: "aa", Count: 5},
+		{Prefix: "bb", Count: 3},
+		{Prefix: "cc", Count: 1}, // below threshold
+	}
+
+	srv := &Server{cfg: &Config{}}
+	coverage := srv.computeColdStartCoverage(edges)
+
+	// 2 out of 3 prefixes have >=3 observations = 66.7%
+	if coverage < 66.0 || coverage > 67.0 {
+		t.Errorf("expected ~66.7%% coverage, got %.1f%%", coverage)
+	}
+}
+
+func TestDebugResponseShape(t *testing.T) {
+	edge := newEdge("aaaa1111", "bbbb2222", "bb", 50, time.Now())
+	edge.Resolved = true
+
+	graph := makeTestGraph(edge)
+	srv := makeTestServer(graph)
+	srv.cfg = &Config{APIKey: "test-key"}
+
+	r, _ := http.NewRequest("GET", "/api/debug/affinity", nil)
+	r.Header.Set("X-API-Key", "test-key")
+	w := httptest.NewRecorder()
+	srv.handleDebugAffinity(w, r)
+
+	var resp map[string]interface{}
+	json.NewDecoder(w.Body).Decode(&resp)
+
+	// Verify top-level keys
+	for _, key := range []string{"edges", "resolutions", "stats"} {
+		if _, ok := resp[key]; !ok {
+			t.Errorf("missing top-level key: %s", key)
+		}
+	}
+
+	stats := resp["stats"].(map[string]interface{})
+	for _, key := range []string{"totalEdges", "totalNodes", "resolvedCount", "ambiguousCount", "unresolvedCount", "avgConfidence", "coldStartCoverage", "cacheAge", "lastRebuild"} {
+		if _, ok := stats[key]; !ok {
+			t.Errorf("missing stats key: %s", key)
+		}
+	}
+}

cmd/server/neighbor_graph.go

@@ -0,0 +1,565 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"log"
+	"math"
+	"strings"
+	"sync"
+	"time"
+)
+
+// ─── Constants ─────────────────────────────────────────────────────────────────
+
+const (
+	// After this many observations, count contributes max weight to the score.
+	affinitySaturationCount = 100
+	// Time-decay half-life: 7 days.
+	affinityHalfLifeHours = 168.0
+	// Cache TTL for the built graph.
+	neighborGraphTTL = 5 * time.Minute
+	// Auto-resolve confidence: best must be >= this factor × second-best.
+	affinityConfidenceRatio = 3.0
+	// Minimum observation count to auto-resolve.
+	affinityMinObservations = 3
+)
+
+// affinityLambda = ln(2) / half-life-hours, precomputed.
+var affinityLambda = math.Ln2 / affinityHalfLifeHours
+
+// ─── Data model ────────────────────────────────────────────────────────────────
+
+// edgeKey is the canonical key for an undirected edge (A < B lexicographically).
+// For ambiguous edges where NodeB is unknown, B is the raw prefix prefixed with "prefix:".
+type edgeKey struct {
+	A, B string
+}
+
+func makeEdgeKey(a, b string) edgeKey {
+	if a > b {
+		a, b = b, a
+	}
+	return edgeKey{A: a, B: b}
+}
+
+// NeighborEdge represents a weighted, undirected first-hop neighbor relationship.
+type NeighborEdge struct {
+	NodeA      string            // full pubkey
+	NodeB      string            // full pubkey, or "" if unresolved/ambiguous
+	Prefix     string            // raw hop prefix that established this edge
+	Count      int               // total observations
+	FirstSeen  time.Time         //
+	LastSeen   time.Time         //
+	SNRSum     float64           // running sum for average
+	SNRCount   int               // how many SNR samples
+	Observers  map[string]bool   // observer pubkeys that witnessed
+	Ambiguous  bool              // multiple candidates or zero candidates
+	Candidates []string          // candidate pubkeys when ambiguous
+	Resolved   bool              // true if auto-resolved via Jaccard
+}
+
+// Score computes the affinity score at query time with time decay.
+func (e *NeighborEdge) Score(now time.Time) float64 {
+	countFactor := math.Min(1.0, float64(e.Count)/float64(affinitySaturationCount))
+	hoursSince := now.Sub(e.LastSeen).Hours()
+	if hoursSince < 0 {
+		hoursSince = 0
+	}
+	decay := math.Exp(-affinityLambda * hoursSince)
+	return countFactor * decay
+}
+
+// AvgSNR returns the average SNR, or 0 if no samples.
+func (e *NeighborEdge) AvgSNR() float64 {
+	if e.SNRCount == 0 {
+		return 0
+	}
+	return e.SNRSum / float64(e.SNRCount)
+}
+
+// ─── NeighborGraph ─────────────────────────────────────────────────────────────
+
+// NeighborGraph is a cached, in-memory first-hop neighbor affinity graph.
+type NeighborGraph struct {
+	mu      sync.RWMutex
+	edges   map[edgeKey]*NeighborEdge
+	byNode  map[string][]*NeighborEdge // pubkey → edges involving this node
+	builtAt time.Time
+	logFn   func(prefix, msg string) // optional structured logging callback
+}
+
+// NewNeighborGraph creates an empty graph.
+func NewNeighborGraph() *NeighborGraph {
+	return &NeighborGraph{
+		edges:  make(map[edgeKey]*NeighborEdge),
+		byNode: make(map[string][]*NeighborEdge),
+	}
+}
+
+// Neighbors returns all edges for a given node pubkey.
+func (g *NeighborGraph) Neighbors(pubkey string) []*NeighborEdge {
+	g.mu.RLock()
+	defer g.mu.RUnlock()
+	return g.byNode[strings.ToLower(pubkey)]
+}
+
+// AllEdges returns all edges in the graph.
+func (g *NeighborGraph) AllEdges() []*NeighborEdge {
+	g.mu.RLock()
+	defer g.mu.RUnlock()
+	out := make([]*NeighborEdge, 0, len(g.edges))
+	for _, e := range g.edges {
+		out = append(out, e)
+	}
+	return out
+}
+
+// IsStale returns true if the graph cache has expired.
+func (g *NeighborGraph) IsStale() bool {
+	g.mu.RLock()
+	defer g.mu.RUnlock()
+	return g.builtAt.IsZero() || time.Since(g.builtAt) > neighborGraphTTL
+}
+
+// ─── Builder ───────────────────────────────────────────────────────────────────
+
+// BuildFromStore constructs the neighbor graph from all packets in the store.
+// The store's read-lock must NOT be held by the caller.
+func BuildFromStore(store *PacketStore) *NeighborGraph {
+	return BuildFromStoreWithLog(store, false)
+}
+
+// cachedToLower returns strings.ToLower(s), caching results to avoid
+// repeated allocations for the same pubkey string.
+func cachedToLower(cache map[string]string, s string) string {
+	if v, ok := cache[s]; ok {
+		return v
+	}
+	v := strings.ToLower(s)
+	cache[s] = v
+	return v
+}
+
+// BuildFromStoreWithLog constructs the neighbor graph, optionally logging disambiguation decisions.
+func BuildFromStoreWithLog(store *PacketStore, enableLog bool) *NeighborGraph {
+	g := NewNeighborGraph()
+	if enableLog {
+		g.logFn = func(prefix, msg string) {
+			log.Printf("[affinity] resolve %s: %s", prefix, msg)
+		}
+	}
+
+	store.mu.RLock()
+	// Snapshot what we need under lock.
+	packets := make([]*StoreTx, len(store.packets))
+	copy(packets, store.packets)
+	store.mu.RUnlock()
+
+	// Build prefix map for candidate resolution.
+	// Use cached nodes+PM (avoids DB call if cache is fresh).
+	_, pm := store.getCachedNodesAndPM()
+
+	// Local cache for strings.ToLower — pubkeys are immutable and repeat
+	// across hundreds of thousands of observations.
+	lowerCache := make(map[string]string, 256)
+
+	// Phase 1: Extract edges from every transmission + observation.
+	for _, tx := range packets {
+		isAdvert := tx.PayloadType != nil && *tx.PayloadType == 4
+		fromNode := extractFromNode(tx)
+		// Pre-compute lowered originator once per tx (not per observation).
+		fromLower := ""
+		if fromNode != "" {
+			fromLower = cachedToLower(lowerCache, fromNode)
+		}
+
+		for _, obs := range tx.Observations {
+			path := parsePathJSON(obs.PathJSON)
+			observerPK := cachedToLower(lowerCache, obs.ObserverID)
+
+			if len(path) == 0 {
+				// Zero-hop
+				if isAdvert && fromLower != "" {
+					if fromLower != observerPK { // self-edge guard
+						g.upsertEdge(fromLower, observerPK, "", observerPK, obs.SNR, parseTimestamp(obs.Timestamp))
+					}
+				}
+				continue
+			}
+
+			// Edge 1: originator ↔ path[0] — ADVERTs only
+			if isAdvert && fromLower != "" {
+				firstHop := cachedToLower(lowerCache, path[0])
+				if fromLower != firstHop { // self-edge guard (shouldn't happen but spec says check)
+					candidates := pm.m[firstHop]
+					g.upsertEdgeWithCandidates(fromLower, firstHop, candidates, observerPK, obs.SNR, parseTimestamp(obs.Timestamp), lowerCache)
+				}
+			}
+
+			// Edge 2: observer ↔ path[last] — ALL packet types
+			lastHop := cachedToLower(lowerCache, path[len(path)-1])
+			if observerPK != lastHop { // self-edge guard
+				candidates := pm.m[lastHop]
+				g.upsertEdgeWithCandidates(observerPK, lastHop, candidates, observerPK, obs.SNR, parseTimestamp(obs.Timestamp), lowerCache)
+			}
+		}
+	}
+
+	// Phase 2: Disambiguation via Jaccard similarity.
+	g.disambiguate()
+
+	g.mu.Lock()
+	g.builtAt = time.Now()
+	g.mu.Unlock()
+
+	return g
+}
+
+// extractFromNode pulls the originator pubkey from a StoreTx's DecodedJSON.
+// ADVERTs use "pubKey", other packets may use "from_node" or "from".
+// Uses the cached ParsedDecoded() accessor to avoid repeated json.Unmarshal.
+func extractFromNode(tx *StoreTx) string {
+	decoded := tx.ParsedDecoded()
+	if decoded == nil {
+		return ""
+	}
+	// ADVERTs store the originator pubkey as "pubKey"; other packets may use
+	// "from_node" or "from".  Check all three so we never miss the originator.
+	for _, field := range []string{"pubKey", "from_node", "from"} {
+		if v, ok := decoded[field]; ok {
+			if s, ok := v.(string); ok && s != "" {
+				return s
+			}
+		}
+	}
+	return ""
+}
+
+// jsonUnmarshalFast is a thin wrapper; could be optimized later.
+func jsonUnmarshalFast(data string, v interface{}) error {
+	return json.Unmarshal([]byte(data), v)
+}
+
+// upsertEdge adds/updates an edge between two fully-known pubkeys.
+func (g *NeighborGraph) upsertEdge(pubkeyA, pubkeyB, prefix, observer string, snr *float64, ts time.Time) {
+	key := makeEdgeKey(pubkeyA, pubkeyB)
+
+	g.mu.Lock()
+	defer g.mu.Unlock()
+
+	e, exists := g.edges[key]
+	if !exists {
+		e = &NeighborEdge{
+			NodeA:     key.A,
+			NodeB:     key.B,
+			Prefix:    prefix,
+			Observers: make(map[string]bool),
+			FirstSeen: ts,
+			LastSeen:  ts,
+		}
+		g.edges[key] = e
+		g.byNode[key.A] = append(g.byNode[key.A], e)
+		g.byNode[key.B] = append(g.byNode[key.B], e)
+	}
+
+	e.Count++
+	if ts.After(e.LastSeen) {
+		e.LastSeen = ts
+	}
+	if ts.Before(e.FirstSeen) {
+		e.FirstSeen = ts
+	}
+	if snr != nil {
+		e.SNRSum += *snr
+		e.SNRCount++
+	}
+	if observer != "" {
+		e.Observers[observer] = true
+	}
+}
+
+// upsertEdgeWithCandidates handles prefix-based edges that may be ambiguous.
+func (g *NeighborGraph) upsertEdgeWithCandidates(knownPK, prefix string, candidates []nodeInfo, observer string, snr *float64, ts time.Time, lc map[string]string) {
+	if len(candidates) == 1 {
+		resolved := cachedToLower(lc, candidates[0].PublicKey)
+		if resolved == knownPK {
+			return // self-edge guard
+		}
+		g.upsertEdge(knownPK, resolved, prefix, observer, snr, ts)
+		return
+	}
+
+	// Filter out self from candidates
+	filtered := make([]string, 0, len(candidates))
+	for _, c := range candidates {
+		pk := cachedToLower(lc, c.PublicKey)
+		if pk != knownPK {
+			filtered = append(filtered, pk)
+		}
+	}
+
+	if len(filtered) == 1 {
+		g.upsertEdge(knownPK, filtered[0], prefix, observer, snr, ts)
+		return
+	}
+
+	// Ambiguous or orphan: use prefix-based key
+	pseudoB := "prefix:" + prefix
+	key := makeEdgeKey(knownPK, pseudoB)
+
+	g.mu.Lock()
+	defer g.mu.Unlock()
+
+	e, exists := g.edges[key]
+	if !exists {
+		e = &NeighborEdge{
+			NodeA:      key.A,
+			NodeB:      "",
+			Prefix:     prefix,
+			Observers:  make(map[string]bool),
+			Ambiguous:  true,
+			Candidates: filtered,
+			FirstSeen:  ts,
+			LastSeen:   ts,
+		}
+		g.edges[key] = e
+		g.byNode[knownPK] = append(g.byNode[knownPK], e)
+	}
+
+	e.Count++
+	if ts.After(e.LastSeen) {
+		e.LastSeen = ts
+	}
+	if ts.Before(e.FirstSeen) {
+		e.FirstSeen = ts
+	}
+	if snr != nil {
+		e.SNRSum += *snr
+		e.SNRCount++
+	}
+	if observer != "" {
+		e.Observers[observer] = true
+	}
+}
+
+// ─── Disambiguation ────────────────────────────────────────────────────────────
+
+// disambiguate resolves ambiguous edges using Jaccard similarity of neighbor sets.
+// Only fully-resolved edges are used as evidence (transitivity poisoning guard).
+func (g *NeighborGraph) disambiguate() {
+	g.mu.Lock()
+	defer g.mu.Unlock()
+
+	// Build resolved neighbor sets: for each node, collect the set of nodes
+	// it has fully-resolved (non-ambiguous) edges with.
+	resolvedNeighbors := make(map[string]map[string]bool)
+	for _, e := range g.edges {
+		if e.Ambiguous || e.NodeB == "" {
+			continue
+		}
+		if resolvedNeighbors[e.NodeA] == nil {
+			resolvedNeighbors[e.NodeA] = make(map[string]bool)
+		}
+		if resolvedNeighbors[e.NodeB] == nil {
+			resolvedNeighbors[e.NodeB] = make(map[string]bool)
+		}
+		resolvedNeighbors[e.NodeA][e.NodeB] = true
+		resolvedNeighbors[e.NodeB][e.NodeA] = true
+	}
+
+	// Try to resolve each ambiguous edge.
+	for key, e := range g.edges {
+		if !e.Ambiguous || len(e.Candidates) < 2 {
+			continue
+		}
+		if e.Count < affinityMinObservations {
+			continue
+		}
+
+		// Determine the known node (the one that's a real pubkey, not the prefix side).
+		knownNode := e.NodeA
+		if strings.HasPrefix(e.NodeA, "prefix:") {
+			knownNode = e.NodeB
+		}
+		// If knownNode is empty (shouldn't happen for ambiguous edges with candidates), skip.
+		if knownNode == "" {
+			continue
+		}
+
+		knownNeighbors := resolvedNeighbors[knownNode]
+
+		type scored struct {
+			pubkey  string
+			jaccard float64
+		}
+		var scores []scored
+
+		for _, cand := range e.Candidates {
+			candNeighbors := resolvedNeighbors[cand]
+			j := jaccardSimilarity(knownNeighbors, candNeighbors)
+			scores = append(scores, scored{cand, j})
+		}
+
+		if len(scores) < 2 {
+			continue
+		}
+
+		// Find best and second-best.
+		best, secondBest := scores[0], scores[1]
+		if secondBest.jaccard > best.jaccard {
+			best, secondBest = secondBest, best
+		}
+		for i := 2; i < len(scores); i++ {
+			if scores[i].jaccard > best.jaccard {
+				secondBest = best
+				best = scores[i]
+			} else if scores[i].jaccard > secondBest.jaccard {
+				secondBest = scores[i]
+			}
+		}
+
+		// Auto-resolve only if best >= 3× second-best AND enough observations.
+		if secondBest.jaccard == 0 {
+			// If second-best is 0 and best > 0, ratio is infinite → resolve.
+			if best.jaccard > 0 {
+				if g.logFn != nil {
+					g.logFn(e.Prefix, fmt.Sprintf("%s score=%d Jaccard=%.2f vs %s score=%d Jaccard=%.2f → neighbor_affinity (ratio ∞)",
+						best.pubkey[:minLen(best.pubkey, 8)], e.Count, best.jaccard,
+						secondBest.pubkey[:minLen(secondBest.pubkey, 8)], e.Count, secondBest.jaccard))
+				}
+				g.resolveEdge(key, e, knownNode, best.pubkey)
+			}
+		} else if best.jaccard/secondBest.jaccard >= affinityConfidenceRatio {
+			ratio := best.jaccard / secondBest.jaccard
+			if g.logFn != nil {
+				g.logFn(e.Prefix, fmt.Sprintf("%s score=%d Jaccard=%.2f vs %s score=%d Jaccard=%.2f → neighbor_affinity (ratio %.1f×)",
+					best.pubkey[:minLen(best.pubkey, 8)], e.Count, best.jaccard,
+					secondBest.pubkey[:minLen(secondBest.pubkey, 8)], e.Count, secondBest.jaccard, ratio))
+			}
+			g.resolveEdge(key, e, knownNode, best.pubkey)
+		} else {
+			// Ambiguous
+			if g.logFn != nil {
+				ratio := 0.0
+				if secondBest.jaccard > 0 {
+					ratio = best.jaccard / secondBest.jaccard
+				}
+				g.logFn(e.Prefix, fmt.Sprintf("scores too close (Jaccard %.2f vs %.2f, ratio %.1f×) → ambiguous, returning %d candidates",
+					best.jaccard, secondBest.jaccard, ratio, len(e.Candidates)))
+			}
+		}
+	}
+}
+
+// resolveEdge converts an ambiguous edge to a resolved one.
+// Must be called with g.mu held.
+func (g *NeighborGraph) resolveEdge(oldKey edgeKey, e *NeighborEdge, knownNode, resolvedPK string) {
+	// Remove old edge.
+	delete(g.edges, oldKey)
+	g.removeFromByNode(oldKey.A, e)
+	g.removeFromByNode(oldKey.B, e)
+
+	// Update edge.
+	newKey := makeEdgeKey(knownNode, resolvedPK)
+	e.NodeA = newKey.A
+	e.NodeB = newKey.B
+	e.Ambiguous = false
+	e.Resolved = true
+
+	// Merge with existing edge if any.
+	if existing, ok := g.edges[newKey]; ok {
+		existing.Count += e.Count
+		if e.LastSeen.After(existing.LastSeen) {
+			existing.LastSeen = e.LastSeen
+		}
+		if e.FirstSeen.Before(existing.FirstSeen) {
+			existing.FirstSeen = e.FirstSeen
+		}
+		existing.SNRSum += e.SNRSum
+		existing.SNRCount += e.SNRCount
+		for obs := range e.Observers {
+			existing.Observers[obs] = true
+		}
+		return
+	}
+
+	g.edges[newKey] = e
+	g.byNode[newKey.A] = append(g.byNode[newKey.A], e)
+	g.byNode[newKey.B] = append(g.byNode[newKey.B], e)
+}
+
+// removeFromByNode removes an edge from the byNode index for the given key.
+func (g *NeighborGraph) removeFromByNode(nodeKey string, edge *NeighborEdge) {
+	edges := g.byNode[nodeKey]
+	for i, e := range edges {
+		if e == edge {
+			g.byNode[nodeKey] = append(edges[:i], edges[i+1:]...)
+			return
+		}
+	}
+}
+
+// jaccardSimilarity computes |A ∩ B| / |A ∪ B|.
+func jaccardSimilarity(a, b map[string]bool) float64 {
+	if len(a) == 0 && len(b) == 0 {
+		return 0
+	}
+	intersection := 0
+	for k := range a {
+		if b[k] {
+			intersection++
+		}
+	}
+	union := len(a) + len(b) - intersection
+	if union == 0 {
+		return 0
+	}
+	return float64(intersection) / float64(union)
+}
+
+// parseTimestamp parses a timestamp string into time.Time.
+func parseTimestamp(s string) time.Time {
+	// Try common formats.
+	for _, fmt := range []string{
+		time.RFC3339,
+		"2006-01-02T15:04:05Z",
+		"2006-01-02 15:04:05",
+		"2006-01-02T15:04:05.000Z",
+	} {
+		if t, err := time.Parse(fmt, s); err == nil {
+			return t
+		}
+	}
+	return time.Time{}
+}
+
+
+// minLen returns the smaller of n and len(s).
+func minLen(s string, n int) int {
+	if len(s) < n {
+		return len(s)
+	}
+	return n
+}
+
+// PruneOlderThan removes all edges with LastSeen before cutoff.
+// Returns the number of edges removed.
+func (g *NeighborGraph) PruneOlderThan(cutoff time.Time) int {
+	g.mu.Lock()
+	defer g.mu.Unlock()
+
+	pruned := 0
+	for key, edge := range g.edges {
+		if edge.LastSeen.Before(cutoff) {
+			// Remove from byNode index
+			g.removeFromByNode(edge.NodeA, edge)
+			if edge.NodeB != "" {
+				g.removeFromByNode(edge.NodeB, edge)
+			}
+			delete(g.edges, key)
+			pruned++
+		}
+	}
+	return pruned
+}

cmd/server/neighbor_graph_test.go

@@ -0,0 +1,836 @@
+package main
+
+import (
+	"encoding/json"
+	"math"
+	"testing"
+	"time"
+)
+
+// ─── Helpers ───────────────────────────────────────────────────────────────────
+
+// ngTestStore creates a minimal PacketStore with injected nodes and packets.
+func ngTestStore(nodes []nodeInfo, packets []*StoreTx) *PacketStore {
+	if nodes == nil {
+		nodes = []nodeInfo{}
+	}
+	if packets == nil {
+		packets = []*StoreTx{}
+	}
+	ps := &PacketStore{
+		packets:        packets,
+		byHash:         make(map[string]*StoreTx),
+		byTxID:         make(map[int]*StoreTx),
+		byObsID:        make(map[int]*StoreObs),
+		byObserver:     make(map[string][]*StoreObs),
+		byNode:         make(map[string][]*StoreTx),
+		nodeHashes:     make(map[string]map[string]bool),
+		byPayloadType:  make(map[int][]*StoreTx),
+		rfCache:        make(map[string]*cachedResult),
+		topoCache:      make(map[string]*cachedResult),
+		hashCache:      make(map[string]*cachedResult),
+		collisionCache: make(map[string]*cachedResult),
+		chanCache:      make(map[string]*cachedResult),
+		distCache:      make(map[string]*cachedResult),
+		subpathCache:   make(map[string]*cachedResult),
+		spIndex:        make(map[string]int),
+	}
+	ps.nodeCache = nodes
+	ps.nodePM = buildPrefixMap(nodes)
+	ps.nodeCacheTime = time.Now().Add(1 * time.Hour)
+	return ps
+}
+
+func ngIntPtr(v int) *int         { return &v }
+func ngFloatPtr(v float64) *float64 { return &v }
+
+func ngMakeTx(id int, payloadType int, decodedJSON string, obs []*StoreObs) *StoreTx {
+	tx := &StoreTx{
+		ID:           id,
+		PayloadType:  ngIntPtr(payloadType),
+		DecodedJSON:  decodedJSON,
+		Observations: obs,
+	}
+	return tx
+}
+
+func ngMakeObs(observerID, pathJSON, timestamp string, snr *float64) *StoreObs {
+	return &StoreObs{
+		ObserverID: observerID,
+		PathJSON:   pathJSON,
+		Timestamp:  timestamp,
+		SNR:        snr,
+	}
+}
+
+func ngFromNodeJSON(pubkey string) string {
+	b, _ := json.Marshal(map[string]string{"from_node": pubkey})
+	return string(b)
+}
+
+var now = time.Now()
+var nowStr = now.UTC().Format(time.RFC3339)
+var weekAgoStr = now.Add(-7 * 24 * time.Hour).UTC().Format(time.RFC3339)
+var monthAgoStr = now.Add(-30 * 24 * time.Hour).UTC().Format(time.RFC3339)
+
+// ─── Tests ─────────────────────────────────────────────────────────────────────
+
+func TestBuildNeighborGraph_EmptyStore(t *testing.T) {
+	store := ngTestStore(nil, nil)
+	g := BuildFromStore(store)
+	if len(g.edges) != 0 {
+		t.Errorf("expected 0 edges, got %d", len(g.edges))
+	}
+}
+
+func TestBuildNeighborGraph_AdvertSingleHopPath(t *testing.T) {
+	// ADVERT from X, path=["R1_prefix"] → edges: X↔R1 and Observer↔R1
+	nodes := []nodeInfo{
+		{PublicKey: "aaaa1111", Name: "NodeX"},
+		{PublicKey: "r1aabbcc", Name: "R1"},
+		{PublicKey: "obs00001", Name: "Observer"},
+	}
+	tx := ngMakeTx(1, 4, ngFromNodeJSON("aaaa1111"), []*StoreObs{
+		ngMakeObs("obs00001", `["r1aa"]`, nowStr, ngFloatPtr(-10)),
+	})
+	store := ngTestStore(nodes, []*StoreTx{tx})
+	g := BuildFromStore(store)
+
+	// Should have 2 edges: X↔R1 and Observer↔R1
+	// But since path has 1 element, path[0]==path[last], so for ADVERTs
+	// both edge types point to the same hop. X↔R1 and Obs↔R1 = 2 edges.
+	edges := g.AllEdges()
+	if len(edges) != 2 {
+		t.Fatalf("expected 2 edges, got %d", len(edges))
+	}
+
+	// Check X↔R1 exists
+	found := false
+	for _, e := range edges {
+		if (e.NodeA == "aaaa1111" && e.NodeB == "r1aabbcc") ||
+			(e.NodeA == "r1aabbcc" && e.NodeB == "aaaa1111") {
+			found = true
+		}
+	}
+	if !found {
+		t.Error("missing originator↔path[0] edge (X↔R1)")
+	}
+
+	// Check Observer↔R1 exists
+	found = false
+	for _, e := range edges {
+		if (e.NodeA == "obs00001" && e.NodeB == "r1aabbcc") ||
+			(e.NodeA == "r1aabbcc" && e.NodeB == "obs00001") {
+			found = true
+		}
+	}
+	if !found {
+		t.Error("missing observer↔path[last] edge (Observer↔R1)")
+	}
+}
+
+func TestBuildNeighborGraph_AdvertMultiHopPath(t *testing.T) {
+	// ADVERT from X, path=["R1","R2"] → X↔R1 and Observer↔R2
+	nodes := []nodeInfo{
+		{PublicKey: "aaaa1111", Name: "NodeX"},
+		{PublicKey: "r1aabbcc", Name: "R1"},
+		{PublicKey: "r2ddeeff", Name: "R2"},
+		{PublicKey: "obs00001", Name: "Observer"},
+	}
+	tx := ngMakeTx(1, 4, ngFromNodeJSON("aaaa1111"), []*StoreObs{
+		ngMakeObs("obs00001", `["r1aa","r2dd"]`, nowStr, nil),
+	})
+	store := ngTestStore(nodes, []*StoreTx{tx})
+	g := BuildFromStore(store)
+
+	edges := g.AllEdges()
+	if len(edges) != 2 {
+		t.Fatalf("expected 2 edges, got %d", len(edges))
+	}
+
+	// X↔R1
+	hasXR1 := false
+	hasObsR2 := false
+	for _, e := range edges {
+		if (e.NodeA == "aaaa1111" && e.NodeB == "r1aabbcc") || (e.NodeA == "r1aabbcc" && e.NodeB == "aaaa1111") {
+			hasXR1 = true
+		}
+		if (e.NodeA == "obs00001" && e.NodeB == "r2ddeeff") || (e.NodeA == "r2ddeeff" && e.NodeB == "obs00001") {
+			hasObsR2 = true
+		}
+	}
+	if !hasXR1 {
+		t.Error("missing X↔R1 edge")
+	}
+	if !hasObsR2 {
+		t.Error("missing Observer↔R2 edge")
+	}
+}
+
+func TestBuildNeighborGraph_AdvertZeroHop(t *testing.T) {
+	// ADVERT from X, path=[] → X↔Observer direct edge
+	nodes := []nodeInfo{
+		{PublicKey: "aaaa1111", Name: "NodeX"},
+		{PublicKey: "obs00001", Name: "Observer"},
+	}
+	tx := ngMakeTx(1, 4, ngFromNodeJSON("aaaa1111"), []*StoreObs{
+		ngMakeObs("obs00001", `[]`, nowStr, nil),
+	})
+	store := ngTestStore(nodes, []*StoreTx{tx})
+	g := BuildFromStore(store)
+
+	edges := g.AllEdges()
+	if len(edges) != 1 {
+		t.Fatalf("expected 1 edge, got %d", len(edges))
+	}
+	e := edges[0]
+	if !((e.NodeA == "aaaa1111" && e.NodeB == "obs00001") || (e.NodeA == "obs00001" && e.NodeB == "aaaa1111")) {
+		t.Errorf("expected X↔Observer edge, got %s↔%s", e.NodeA, e.NodeB)
+	}
+	if e.Ambiguous {
+		t.Error("zero-hop edge should not be ambiguous")
+	}
+}
+
+func TestBuildNeighborGraph_NonAdvertEmptyPath(t *testing.T) {
+	// Non-ADVERT, path=[] → no edges
+	nodes := []nodeInfo{
+		{PublicKey: "aaaa1111", Name: "NodeX"},
+		{PublicKey: "obs00001", Name: "Observer"},
+	}
+	tx := ngMakeTx(1, 2, ngFromNodeJSON("aaaa1111"), []*StoreObs{
+		ngMakeObs("obs00001", `[]`, nowStr, nil),
+	})
+	store := ngTestStore(nodes, []*StoreTx{tx})
+	g := BuildFromStore(store)
+
+	if len(g.edges) != 0 {
+		t.Errorf("expected 0 edges for non-ADVERT empty path, got %d", len(g.edges))
+	}
+}
+
+func TestBuildNeighborGraph_NonAdvertOnlyObserverEdge(t *testing.T) {
+	// Non-ADVERT with path=["R1","R2"] → only Observer↔R2, NO originator edge
+	nodes := []nodeInfo{
+		{PublicKey: "aaaa1111", Name: "NodeX"},
+		{PublicKey: "r1aabbcc", Name: "R1"},
+		{PublicKey: "r2ddeeff", Name: "R2"},
+		{PublicKey: "obs00001", Name: "Observer"},
+	}
+	tx := ngMakeTx(1, 2, ngFromNodeJSON("aaaa1111"), []*StoreObs{
+		ngMakeObs("obs00001", `["r1aa","r2dd"]`, nowStr, nil),
+	})
+	store := ngTestStore(nodes, []*StoreTx{tx})
+	g := BuildFromStore(store)
+
+	edges := g.AllEdges()
+	if len(edges) != 1 {
+		t.Fatalf("expected 1 edge, got %d", len(edges))
+	}
+	e := edges[0]
+	if !((e.NodeA == "obs00001" && e.NodeB == "r2ddeeff") || (e.NodeA == "r2ddeeff" && e.NodeB == "obs00001")) {
+		t.Errorf("expected Observer↔R2 edge, got %s↔%s", e.NodeA, e.NodeB)
+	}
+}
+
+func TestBuildNeighborGraph_NonAdvertSingleHop(t *testing.T) {
+	// Non-ADVERT with path=["R1"] → Observer↔R1 only
+	nodes := []nodeInfo{
+		{PublicKey: "aaaa1111", Name: "NodeX"},
+		{PublicKey: "r1aabbcc", Name: "R1"},
+		{PublicKey: "obs00001", Name: "Observer"},
+	}
+	tx := ngMakeTx(1, 2, ngFromNodeJSON("aaaa1111"), []*StoreObs{
+		ngMakeObs("obs00001", `["r1aa"]`, nowStr, nil),
+	})
+	store := ngTestStore(nodes, []*StoreTx{tx})
+	g := BuildFromStore(store)
+
+	edges := g.AllEdges()
+	if len(edges) != 1 {
+		t.Fatalf("expected 1 edge, got %d", len(edges))
+	}
+	e := edges[0]
+	if !((e.NodeA == "obs00001" && e.NodeB == "r1aabbcc") || (e.NodeA == "r1aabbcc" && e.NodeB == "obs00001")) {
+		t.Errorf("expected Observer↔R1, got %s↔%s", e.NodeA, e.NodeB)
+	}
+}
+
+func TestBuildNeighborGraph_HashCollision(t *testing.T) {
+	// Two nodes share prefix "a3" → ambiguous edge
+	nodes := []nodeInfo{
+		{PublicKey: "aaaa1111", Name: "NodeX"},
+		{PublicKey: "a3bb1111", Name: "CandidateA"},
+		{PublicKey: "a3bb2222", Name: "CandidateB"},
+		{PublicKey: "obs00001", Name: "Observer"},
+	}
+	tx := ngMakeTx(1, 4, ngFromNodeJSON("aaaa1111"), []*StoreObs{
+		ngMakeObs("obs00001", `["a3bb"]`, nowStr, nil),
+	})
+	store := ngTestStore(nodes, []*StoreTx{tx})
+	g := BuildFromStore(store)
+
+	// Should have ambiguous edges
+	var ambigCount int
+	for _, e := range g.AllEdges() {
+		if e.Ambiguous {
+			ambigCount++
+			if len(e.Candidates) < 2 {
+				t.Errorf("expected >=2 candidates, got %d", len(e.Candidates))
+			}
+		}
+	}
+	if ambigCount == 0 {
+		t.Error("expected at least one ambiguous edge for hash collision")
+	}
+}
+
+func TestBuildNeighborGraph_JaccardScoring(t *testing.T) {
+	// Test Jaccard similarity computation directly
+	a := map[string]bool{"x": true, "y": true, "z": true}
+	b := map[string]bool{"y": true, "z": true, "w": true}
+	j := jaccardSimilarity(a, b)
+	// intersection = {y, z} = 2, union = {x, y, z, w} = 4 → 0.5
+	if math.Abs(j-0.5) > 0.001 {
+		t.Errorf("expected Jaccard 0.5, got %f", j)
+	}
+
+	// Empty sets
+	j = jaccardSimilarity(nil, nil)
+	if j != 0 {
+		t.Errorf("expected 0 for empty sets, got %f", j)
+	}
+}
+
+func TestBuildNeighborGraph_ConfidenceAutoResolve(t *testing.T) {
+	// Setup: NodeX has known neighbors N1, N2, N3 (resolved edges).
+	// CandidateA also has known neighbors N1, N2, N3 (high Jaccard with X).
+	// CandidateB has no known neighbors (Jaccard = 0).
+	// An ambiguous edge X↔prefix "a3" with candidates [A, B] should auto-resolve to A.
+	nodes := []nodeInfo{
+		{PublicKey: "aaaa1111", Name: "NodeX"},
+		{PublicKey: "n1111111", Name: "N1"},
+		{PublicKey: "n2222222", Name: "N2"},
+		{PublicKey: "n3333333", Name: "N3"},
+		{PublicKey: "a3001111", Name: "CandidateA"},
+		{PublicKey: "a3002222", Name: "CandidateB"},
+		{PublicKey: "obs00001", Name: "Observer"},
+	}
+
+	// Create resolved edges: X↔N1, X↔N2, X↔N3, A↔N1, A↔N2, A↔N3
+	// Then an ambiguous edge X↔"a300" prefix with 3+ observations.
+	var txs []*StoreTx
+	txID := 1
+
+	// X sends ADVERTs through N1, N2, N3
+	for _, nhop := range []string{"n111", "n222", "n333"} {
+		txs = append(txs, ngMakeTx(txID, 4, ngFromNodeJSON("aaaa1111"), []*StoreObs{
+			ngMakeObs("obs00001", `["`+nhop+`"]`, nowStr, nil),
+		}))
+		txID++
+	}
+
+	// CandidateA sends ADVERTs through N1, N2, N3
+	for _, nhop := range []string{"n111", "n222", "n333"} {
+		txs = append(txs, ngMakeTx(txID, 4, ngFromNodeJSON("a3001111"), []*StoreObs{
+			ngMakeObs("obs00001", `["`+nhop+`"]`, nowStr, nil),
+		}))
+		txID++
+	}
+
+	// Ambiguous edge: X sends ADVERTs with path[0]="a300" (matches both candidates)
+	// Need 3+ observations for confidence threshold.
+	for i := 0; i < 3; i++ {
+		txs = append(txs, ngMakeTx(txID, 4, ngFromNodeJSON("aaaa1111"), []*StoreObs{
+			ngMakeObs("obs00001", `["a300"]`, nowStr, nil),
+		}))
+		txID++
+	}
+
+	store := ngTestStore(nodes, txs)
+	g := BuildFromStore(store)
+
+	// The ambiguous edge X↔a300 should have been resolved to CandidateA
+	neighbors := g.Neighbors("aaaa1111")
+	foundA := false
+	for _, e := range neighbors {
+		other := e.NodeB
+		if e.NodeA != "aaaa1111" {
+			other = e.NodeA
+		}
+		if other == "a3001111" {
+			foundA = true
+			if e.Ambiguous {
+				t.Error("edge should have been resolved (not ambiguous)")
+			}
+		}
+	}
+	if !foundA {
+		t.Error("expected edge X↔CandidateA to be auto-resolved")
+	}
+}
+
+func TestBuildNeighborGraph_EqualScoresAmbiguous(t *testing.T) {
+	// Two candidates with identical neighbor sets → should NOT auto-resolve.
+	nodes := []nodeInfo{
+		{PublicKey: "aaaa1111", Name: "NodeX"},
+		{PublicKey: "n1111111", Name: "N1"},
+		{PublicKey: "a3001111", Name: "CandidateA"},
+		{PublicKey: "a3002222", Name: "CandidateB"},
+		{PublicKey: "obs00001", Name: "Observer"},
+	}
+
+	var txs []*StoreTx
+	txID := 1
+
+	// X↔N1
+	txs = append(txs, ngMakeTx(txID, 4, ngFromNodeJSON("aaaa1111"), []*StoreObs{
+		ngMakeObs("obs00001", `["n111"]`, nowStr, nil),
+	}))
+	txID++
+
+	// Both candidates have same neighbor (N1)
+	txs = append(txs, ngMakeTx(txID, 4, ngFromNodeJSON("a3001111"), []*StoreObs{
+		ngMakeObs("obs00001", `["n111"]`, nowStr, nil),
+	}))
+	txID++
+	txs = append(txs, ngMakeTx(txID, 4, ngFromNodeJSON("a3002222"), []*StoreObs{
+		ngMakeObs("obs00001", `["n111"]`, nowStr, nil),
+	}))
+	txID++
+
+	// Ambiguous edge with 3+ observations
+	for i := 0; i < 3; i++ {
+		txs = append(txs, ngMakeTx(txID, 4, ngFromNodeJSON("aaaa1111"), []*StoreObs{
+			ngMakeObs("obs00001", `["a300"]`, nowStr, nil),
+		}))
+		txID++
+	}
+
+	store := ngTestStore(nodes, txs)
+	g := BuildFromStore(store)
+
+	// Should remain ambiguous
+	var ambigFound bool
+	for _, e := range g.AllEdges() {
+		if e.Ambiguous && e.Prefix == "a300" {
+			ambigFound = true
+		}
+	}
+	if !ambigFound {
+		t.Error("expected ambiguous edge to remain unresolved with equal scores")
+	}
+}
+
+func TestBuildNeighborGraph_ObserverSelfEdgeGuard(t *testing.T) {
+	// Observer's own prefix in path → should NOT create self-edge.
+	nodes := []nodeInfo{
+		{PublicKey: "aaaa1111", Name: "NodeX"},
+		{PublicKey: "obs00001", Name: "Observer"},
+	}
+	tx := ngMakeTx(1, 4, ngFromNodeJSON("aaaa1111"), []*StoreObs{
+		ngMakeObs("obs00001", `["obs0"]`, nowStr, nil),
+	})
+	store := ngTestStore(nodes, []*StoreTx{tx})
+	g := BuildFromStore(store)
+
+	// Check no self-edge for observer
+	for _, e := range g.AllEdges() {
+		if e.NodeA == e.NodeB && e.NodeA == "obs00001" {
+			t.Error("self-edge created for observer")
+		}
+	}
+}
+
+func TestBuildNeighborGraph_OrphanPrefix(t *testing.T) {
+	// Path contains prefix matching zero nodes → edge recorded as unresolved.
+	nodes := []nodeInfo{
+		{PublicKey: "aaaa1111", Name: "NodeX"},
+		{PublicKey: "obs00001", Name: "Observer"},
+	}
+	tx := ngMakeTx(1, 4, ngFromNodeJSON("aaaa1111"), []*StoreObs{
+		ngMakeObs("obs00001", `["ff99"]`, nowStr, nil),
+	})
+	store := ngTestStore(nodes, []*StoreTx{tx})
+	g := BuildFromStore(store)
+
+	// Should have ambiguous edges with empty candidates.
+	var orphanFound bool
+	for _, e := range g.AllEdges() {
+		if e.Ambiguous && len(e.Candidates) == 0 {
+			orphanFound = true
+			if e.Prefix != "ff99" {
+				t.Errorf("expected prefix ff99, got %s", e.Prefix)
+			}
+		}
+	}
+	if !orphanFound {
+		t.Error("expected orphan prefix edge with empty candidates")
+	}
+}
+
+func TestAffinityScore_Fresh(t *testing.T) {
+	e := &NeighborEdge{Count: 100, LastSeen: time.Now()}
+	s := e.Score(time.Now())
+	if s < 0.99 || s > 1.0 {
+		t.Errorf("expected score ≈ 1.0, got %f", s)
+	}
+}
+
+func TestAffinityScore_Decayed(t *testing.T) {
+	e := &NeighborEdge{Count: 100, LastSeen: time.Now().Add(-7 * 24 * time.Hour)}
+	s := e.Score(time.Now())
+	// 7 days → half-life → ~0.5
+	if math.Abs(s-0.5) > 0.05 {
+		t.Errorf("expected score ≈ 0.5, got %f", s)
+	}
+}
+
+func TestAffinityScore_LowCount(t *testing.T) {
+	e := &NeighborEdge{Count: 5, LastSeen: time.Now()}
+	s := e.Score(time.Now())
+	// 5/100 = 0.05
+	if math.Abs(s-0.05) > 0.01 {
+		t.Errorf("expected score ≈ 0.05, got %f", s)
+	}
+}
+
+func TestAffinityScore_StaleAndLow(t *testing.T) {
+	e := &NeighborEdge{Count: 5, LastSeen: time.Now().Add(-30 * 24 * time.Hour)}
+	s := e.Score(time.Now())
+	// Very small
+	if s > 0.01 {
+		t.Errorf("expected score ≈ 0, got %f", s)
+	}
+}
+
+func TestBuildNeighborGraph_CountAccumulation(t *testing.T) {
+	nodes := []nodeInfo{
+		{PublicKey: "aaaa1111", Name: "NodeX"},
+		{PublicKey: "r1aabbcc", Name: "R1"},
+		{PublicKey: "obs00001", Name: "Observer"},
+	}
+
+	var txs []*StoreTx
+	for i := 0; i < 5; i++ {
+		txs = append(txs, ngMakeTx(i+1, 4, ngFromNodeJSON("aaaa1111"), []*StoreObs{
+			ngMakeObs("obs00001", `["r1aa"]`, nowStr, nil),
+		}))
+	}
+
+	store := ngTestStore(nodes, txs)
+	g := BuildFromStore(store)
+
+	// Check count on X↔R1 edge
+	for _, e := range g.AllEdges() {
+		if (e.NodeA == "aaaa1111" && e.NodeB == "r1aabbcc") || (e.NodeA == "r1aabbcc" && e.NodeB == "aaaa1111") {
+			if e.Count != 5 {
+				t.Errorf("expected count 5, got %d", e.Count)
+			}
+			return
+		}
+	}
+	t.Error("X↔R1 edge not found")
+}
+
+func TestBuildNeighborGraph_MultipleObservers(t *testing.T) {
+	nodes := []nodeInfo{
+		{PublicKey: "aaaa1111", Name: "NodeX"},
+		{PublicKey: "r1aabbcc", Name: "R1"},
+		{PublicKey: "obs00001", Name: "Obs1"},
+		{PublicKey: "obs00002", Name: "Obs2"},
+	}
+
+	tx := ngMakeTx(1, 4, ngFromNodeJSON("aaaa1111"), []*StoreObs{
+		ngMakeObs("obs00001", `["r1aa"]`, nowStr, nil),
+		ngMakeObs("obs00002", `["r1aa"]`, nowStr, nil),
+	})
+
+	store := ngTestStore(nodes, []*StoreTx{tx})
+	g := BuildFromStore(store)
+
+	for _, e := range g.AllEdges() {
+		if (e.NodeA == "aaaa1111" && e.NodeB == "r1aabbcc") || (e.NodeA == "r1aabbcc" && e.NodeB == "aaaa1111") {
+			if len(e.Observers) != 2 {
+				t.Errorf("expected 2 observers, got %d", len(e.Observers))
+			}
+			if !e.Observers["obs00001"] || !e.Observers["obs00002"] {
+				t.Error("missing expected observer")
+			}
+			return
+		}
+	}
+	t.Error("X↔R1 edge not found")
+}
+
+func TestBuildNeighborGraph_TimeDecayOldObservations(t *testing.T) {
+	nodes := []nodeInfo{
+		{PublicKey: "aaaa1111", Name: "NodeX"},
+		{PublicKey: "r1aabbcc", Name: "R1"},
+		{PublicKey: "obs00001", Name: "Observer"},
+	}
+
+	tx := ngMakeTx(1, 4, ngFromNodeJSON("aaaa1111"), []*StoreObs{
+		ngMakeObs("obs00001", `["r1aa"]`, monthAgoStr, nil),
+	})
+
+	store := ngTestStore(nodes, []*StoreTx{tx})
+	g := BuildFromStore(store)
+
+	for _, e := range g.AllEdges() {
+		if (e.NodeA == "aaaa1111" && e.NodeB == "r1aabbcc") || (e.NodeA == "r1aabbcc" && e.NodeB == "aaaa1111") {
+			score := e.Score(time.Now())
+			if score > 0.05 {
+				t.Errorf("expected decayed score < 0.05, got %f", score)
+			}
+			return
+		}
+	}
+	t.Error("X↔R1 edge not found")
+}
+
+func TestBuildNeighborGraph_ADVERTOnlyConstraint(t *testing.T) {
+	// Non-ADVERT: should NOT create originator↔path[0] edge, only observer↔path[last].
+	nodes := []nodeInfo{
+		{PublicKey: "aaaa1111", Name: "NodeX"},
+		{PublicKey: "r1aabbcc", Name: "R1"},
+		{PublicKey: "r2ddeeff", Name: "R2"},
+		{PublicKey: "obs00001", Name: "Observer"},
+	}
+	tx := ngMakeTx(1, 2, ngFromNodeJSON("aaaa1111"), []*StoreObs{
+		ngMakeObs("obs00001", `["r1aa","r2dd"]`, nowStr, nil),
+	})
+	store := ngTestStore(nodes, []*StoreTx{tx})
+	g := BuildFromStore(store)
+
+	for _, e := range g.AllEdges() {
+		a, b := e.NodeA, e.NodeB
+		if (a == "aaaa1111" && b == "r1aabbcc") || (a == "r1aabbcc" && b == "aaaa1111") {
+			t.Error("non-ADVERT should NOT produce originator↔path[0] edge")
+		}
+	}
+
+	// Should have Observer↔R2
+	found := false
+	for _, e := range g.AllEdges() {
+		if (e.NodeA == "obs00001" && e.NodeB == "r2ddeeff") || (e.NodeA == "r2ddeeff" && e.NodeB == "obs00001") {
+			found = true
+		}
+	}
+	if !found {
+		t.Error("missing Observer↔R2 edge from non-ADVERT")
+	}
+}
+
+// ngPubKeyJSON creates decoded JSON using the real ADVERT format ("pubKey" field).
+func ngPubKeyJSON(pubkey string) string {
+	b, _ := json.Marshal(map[string]string{"pubKey": pubkey})
+	return string(b)
+}
+
+func TestBuildNeighborGraph_AdvertPubKeyField(t *testing.T) {
+	// Real ADVERTs use "pubKey", not "from_node". Verify the builder handles it.
+	nodes := []nodeInfo{
+		{PublicKey: "99bf37abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234", Name: "Originator"},
+		{PublicKey: "r1aabbccdd001122334455667788990011223344556677889900112233445566", Name: "R1"},
+		{PublicKey: "obs0000100112233445566778899001122334455667788990011223344556677", Name: "Observer"},
+	}
+	tx := ngMakeTx(1, 4, ngPubKeyJSON("99bf37abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234"), []*StoreObs{
+		ngMakeObs("obs0000100112233445566778899001122334455667788990011223344556677", `["r1"]`, nowStr, ngFloatPtr(-8.5)),
+	})
+	store := ngTestStore(nodes, []*StoreTx{tx})
+	g := BuildFromStore(store)
+
+	edges := g.AllEdges()
+	if len(edges) < 1 {
+		t.Fatalf("expected >=1 edges from ADVERT with pubKey field, got %d", len(edges))
+	}
+
+	// Check originator↔R1 edge exists
+	found := false
+	for _, e := range edges {
+		a := e.NodeA
+		b := e.NodeB
+		orig := "99bf37abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234"
+		r1 := "r1aabbccdd001122334455667788990011223344556677889900112233445566"
+		if (a == orig && b == r1) || (a == r1 && b == orig) {
+			found = true
+		}
+	}
+	if !found {
+		t.Error("missing originator↔R1 edge when using pubKey field (real ADVERT format)")
+	}
+}
+
+func TestBuildNeighborGraph_OneByteHashPrefixes(t *testing.T) {
+	// Real-world scenario: 1-byte hash prefixes with multiple candidates.
+	// Should create edges (possibly ambiguous) rather than empty graph.
+	nodes := []nodeInfo{
+		{PublicKey: "c0dedad400000000000000000000000000000000000000000000000000000001", Name: "NodeC0-1"},
+		{PublicKey: "c0dedad900000000000000000000000000000000000000000000000000000002", Name: "NodeC0-2"},
+		{PublicKey: "a3bbccdd00000000000000000000000000000000000000000000000000000003", Name: "Originator"},
+		{PublicKey: "obs1234500000000000000000000000000000000000000000000000000000004", Name: "Observer"},
+	}
+	// ADVERT from Originator with 1-byte path hop "c0"
+	tx := ngMakeTx(1, 4, ngPubKeyJSON("a3bbccdd00000000000000000000000000000000000000000000000000000003"), []*StoreObs{
+		ngMakeObs("obs1234500000000000000000000000000000000000000000000000000000004", `["c0"]`, nowStr, ngFloatPtr(-12)),
+	})
+	store := ngTestStore(nodes, []*StoreTx{tx})
+	g := BuildFromStore(store)
+
+	edges := g.AllEdges()
+	if len(edges) == 0 {
+		t.Fatal("expected non-empty edges for 1-byte hash prefix network, got 0")
+	}
+
+	// The originator↔c0 edge should be ambiguous (2 candidates match "c0")
+	var hasAmbig bool
+	for _, e := range edges {
+		if e.Ambiguous && e.Prefix == "c0" {
+			hasAmbig = true
+			if len(e.Candidates) != 2 {
+				t.Errorf("expected 2 candidates for prefix c0, got %d", len(e.Candidates))
+			}
+		}
+	}
+	if !hasAmbig {
+		// Could be resolved if one candidate was filtered — check we got some edge
+		t.Log("no ambiguous edge found, but edges exist — acceptable if resolved")
+	}
+}
+
+func TestNeighborGraph_CacheTTL(t *testing.T) {
+	g := NewNeighborGraph()
+	if !g.IsStale() {
+		t.Error("new graph should be stale")
+	}
+	g.mu.Lock()
+	g.builtAt = time.Now()
+	g.mu.Unlock()
+	if g.IsStale() {
+		t.Error("just-built graph should not be stale")
+	}
+	g.mu.Lock()
+	g.builtAt = time.Now().Add(-2 * neighborGraphTTL)
+	g.mu.Unlock()
+	if !g.IsStale() {
+		t.Error("old graph should be stale")
+	}
+}
+
+func TestNeighborGraph_TTLIsReasonable(t *testing.T) {
+	// TTL must be long enough to avoid rebuild storms on busy meshes,
+	// but short enough to reflect topology changes within minutes.
+	if neighborGraphTTL < 1*time.Minute {
+		t.Errorf("neighborGraphTTL too short (%v), will cause rebuild storms", neighborGraphTTL)
+	}
+	if neighborGraphTTL > 10*time.Minute {
+		t.Errorf("neighborGraphTTL too long (%v), topology changes will be stale", neighborGraphTTL)
+	}
+}
+
+func TestCachedToLower(t *testing.T) {
+	cache := make(map[string]string)
+	// Basic lowercasing
+	if got := cachedToLower(cache, "AABB"); got != "aabb" {
+		t.Errorf("expected 'aabb', got %q", got)
+	}
+	// Verify it was cached
+	if _, ok := cache["AABB"]; !ok {
+		t.Error("expected 'AABB' to be in cache")
+	}
+	// Same input returns cached result
+	if got := cachedToLower(cache, "AABB"); got != "aabb" {
+		t.Errorf("expected cached 'aabb', got %q", got)
+	}
+	// Already lowercase stays the same
+	if got := cachedToLower(cache, "aabb"); got != "aabb" {
+		t.Errorf("expected 'aabb', got %q", got)
+	}
+	// Empty string
+	if got := cachedToLower(cache, ""); got != "" {
+		t.Errorf("expected empty, got %q", got)
+	}
+}
+
+func TestParsedDecoded_Caching(t *testing.T) {
+	tx := &StoreTx{DecodedJSON: `{"pubKey":"abc123","name":"test"}`}
+	// First call parses
+	d1 := tx.ParsedDecoded()
+	if d1 == nil {
+		t.Fatal("expected non-nil parsed result")
+	}
+	if d1["pubKey"] != "abc123" {
+		t.Errorf("expected pubKey=abc123, got %v", d1["pubKey"])
+	}
+	// Second call must return the exact same map (pointer equality proves caching)
+	d2 := tx.ParsedDecoded()
+	if &d1 == nil || &d2 == nil {
+		t.Fatal("unexpected nil")
+	}
+	// Mutate d1 and verify d2 sees the mutation — proves same underlying map
+	d1["_sentinel"] = true
+	if d2["_sentinel"] != true {
+		t.Error("expected same map instance from second call (caching broken)")
+	}
+	delete(d1, "_sentinel") // clean up
+}
+
+func TestParsedDecoded_EmptyJSON(t *testing.T) {
+	tx := &StoreTx{DecodedJSON: ""}
+	d := tx.ParsedDecoded()
+	if d != nil {
+		t.Errorf("expected nil for empty DecodedJSON, got %v", d)
+	}
+}
+
+func TestParsedDecoded_InvalidJSON(t *testing.T) {
+	tx := &StoreTx{DecodedJSON: "not json"}
+	d := tx.ParsedDecoded()
+	if d != nil {
+		t.Errorf("expected nil for invalid JSON, got %v", d)
+	}
+}
+
+func TestExtractFromNode_UsesCachedParse(t *testing.T) {
+	tx := &StoreTx{DecodedJSON: `{"pubKey":"aabb1122"}`}
+	// First call to extractFromNode should use ParsedDecoded
+	from := extractFromNode(tx)
+	if from != "aabb1122" {
+		t.Errorf("expected aabb1122, got %q", from)
+	}
+	// ParsedDecoded should now be cached
+	d := tx.ParsedDecoded()
+	if d == nil || d["pubKey"] != "aabb1122" {
+		t.Error("expected ParsedDecoded to return cached result")
+	}
+}
+
+func BenchmarkBuildFromStore(b *testing.B) {
+	// Simulate a dataset with many packets and repeated pubkeys
+	nodes := []nodeInfo{
+		{PublicKey: "aaaa1111", Name: "NodeA"},
+		{PublicKey: "bbbb2222", Name: "NodeB"},
+		{PublicKey: "cccc3333", Name: "NodeC"},
+		{PublicKey: "dddd4444", Name: "NodeD"},
+	}
+	const numPackets = 1000
+	packets := make([]*StoreTx, 0, numPackets)
+	for i := 0; i < numPackets; i++ {
+		pt := 4 // ADVERT
+		packets = append(packets, &StoreTx{
+			ID:          i,
+			PayloadType: &pt,
+			DecodedJSON: `{"pubKey":"aaaa1111"}`,
+			Observations: []*StoreObs{
+				{ObserverID: "bbbb2222", PathJSON: `["cccc"]`, Timestamp: nowStr, SNR: ngFloatPtr(-5.0)},
+			},
+		})
+	}
+	store := ngTestStore(nodes, packets)
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		BuildFromStore(store)
+	}
+}

cmd/server/neighbor_persist.go

@@ -0,0 +1,625 @@
+package main
+
+import (
+	"database/sql"
+	"encoding/json"
+	"fmt"
+	"log"
+	"strings"
+	"time"
+)
+
+// persistSem limits concurrent async persistence goroutines to 1.
+// Without this, each ingest cycle spawns a goroutine that opens a new
+// SQLite RW connection; under sustained load goroutines pile up with
+// no backpressure, causing contention and busy-timeout cascades.
+var persistSem = make(chan struct{}, 1)
+
+// ─── neighbor_edges table ──────────────────────────────────────────────────────
+
+// ensureNeighborEdgesTable creates the neighbor_edges table if it doesn't exist.
+// Uses a separate read-write connection since the main DB is read-only.
+func ensureNeighborEdgesTable(dbPath string) error {
+	rw, err := openRW(dbPath)
+	if err != nil {
+		return fmt.Errorf("open rw for neighbor_edges: %w", err)
+	}
+	defer rw.Close()
+
+	_, err = rw.Exec(`CREATE TABLE IF NOT EXISTS neighbor_edges (
+		node_a TEXT NOT NULL,
+		node_b TEXT NOT NULL,
+		count INTEGER DEFAULT 1,
+		last_seen TEXT,
+		PRIMARY KEY (node_a, node_b)
+	)`)
+	return err
+}
+
+// loadNeighborEdgesFromDB loads all edges from the neighbor_edges table
+// and builds an in-memory NeighborGraph.
+func loadNeighborEdgesFromDB(conn *sql.DB) *NeighborGraph {
+	g := NewNeighborGraph()
+
+	rows, err := conn.Query("SELECT node_a, node_b, count, last_seen FROM neighbor_edges")
+	if err != nil {
+		log.Printf("[neighbor] failed to load neighbor_edges: %v", err)
+		return g
+	}
+	defer rows.Close()
+
+	count := 0
+	for rows.Next() {
+		var a, b string
+		var cnt int
+		var lastSeen sql.NullString
+		if err := rows.Scan(&a, &b, &cnt, &lastSeen); err != nil {
+			continue
+		}
+		ts := time.Time{}
+		if lastSeen.Valid {
+			ts = parseTimestamp(lastSeen.String)
+		}
+		// Build edge directly (both nodes are full pubkeys from persisted data)
+		key := makeEdgeKey(a, b)
+		g.mu.Lock()
+		e, exists := g.edges[key]
+		if !exists {
+			e = &NeighborEdge{
+				NodeA:     key.A,
+				NodeB:     key.B,
+				Observers: make(map[string]bool),
+				FirstSeen: ts,
+				LastSeen:  ts,
+				Count:     cnt,
+			}
+			g.edges[key] = e
+			g.byNode[key.A] = append(g.byNode[key.A], e)
+			g.byNode[key.B] = append(g.byNode[key.B], e)
+		} else {
+			e.Count += cnt
+			if ts.After(e.LastSeen) {
+				e.LastSeen = ts
+			}
+		}
+		g.mu.Unlock()
+		count++
+	}
+
+	if count > 0 {
+		g.mu.Lock()
+		g.builtAt = time.Now()
+		g.mu.Unlock()
+		log.Printf("[neighbor] loaded %d edges from neighbor_edges table", count)
+	}
+
+	return g
+}
+
+// ─── shared async persistence helper ───────────────────────────────────────────
+
+// persistObsUpdate holds data for a resolved_path SQLite update.
+type persistObsUpdate struct {
+	obsID        int
+	resolvedPath string
+}
+
+// persistEdgeUpdate holds data for a neighbor_edges SQLite upsert.
+type persistEdgeUpdate struct {
+	a, b, ts string
+}
+
+// asyncPersistResolvedPathsAndEdges writes resolved_path updates and neighbor
+// edge upserts to SQLite in a background goroutine. Shared between
+// IngestNewFromDB and IngestNewObservations to avoid DRY violation.
+func asyncPersistResolvedPathsAndEdges(dbPath string, obsUpdates []persistObsUpdate, edgeUpdates []persistEdgeUpdate, logPrefix string) {
+	if len(obsUpdates) == 0 && len(edgeUpdates) == 0 {
+		return
+	}
+	// Try-acquire semaphore BEFORE spawning goroutine. If another
+	// persistence operation is already running, drop this batch —
+	// data lives in memory and will be backfilled on restart.
+	select {
+	case persistSem <- struct{}{}:
+		// Acquired — spawn goroutine to do the work.
+	default:
+		log.Printf("[store] %s skipped: persistence already in progress", logPrefix)
+		return
+	}
+	go func() {
+		defer func() { <-persistSem }()
+
+		rw, err := openRW(dbPath)
+		if err != nil {
+			log.Printf("[store] %s rw open error: %v", logPrefix, err)
+			return
+		}
+		defer rw.Close()
+
+		if len(obsUpdates) > 0 {
+			sqlTx, err := rw.Begin()
+			if err == nil {
+				stmt, err := sqlTx.Prepare("UPDATE observations SET resolved_path = ? WHERE id = ?")
+				if err == nil {
+					var firstErr error
+					for _, u := range obsUpdates {
+						if _, err := stmt.Exec(u.resolvedPath, u.obsID); err != nil && firstErr == nil {
+							firstErr = err
+						}
+					}
+					stmt.Close()
+					if firstErr != nil {
+						log.Printf("[store] %s resolved_path error (first): %v", logPrefix, firstErr)
+					}
+				} else {
+					log.Printf("[store] %s resolved_path prepare error: %v", logPrefix, err)
+				}
+				sqlTx.Commit()
+			}
+		}
+
+		if len(edgeUpdates) > 0 {
+			sqlTx, err := rw.Begin()
+			if err == nil {
+				stmt, err := sqlTx.Prepare(`INSERT INTO neighbor_edges (node_a, node_b, count, last_seen)
+					VALUES (?, ?, 1, ?)
+					ON CONFLICT(node_a, node_b) DO UPDATE SET
+					count = count + 1, last_seen = MAX(last_seen, excluded.last_seen)`)
+				if err == nil {
+					var firstErr error
+					for _, e := range edgeUpdates {
+						if _, err := stmt.Exec(e.a, e.b, e.ts); err != nil && firstErr == nil {
+							firstErr = err
+						}
+					}
+					stmt.Close()
+					if firstErr != nil {
+						log.Printf("[store] %s edge error (first): %v", logPrefix, firstErr)
+					}
+				} else {
+					log.Printf("[store] %s edge prepare error: %v", logPrefix, err)
+				}
+				sqlTx.Commit()
+			}
+		}
+	}()
+}
+
+// neighborEdgesTableExists checks if the neighbor_edges table has any data.
+func neighborEdgesTableExists(conn *sql.DB) bool {
+	var cnt int
+	err := conn.QueryRow("SELECT COUNT(*) FROM neighbor_edges").Scan(&cnt)
+	if err != nil {
+		return false // table doesn't exist
+	}
+	return cnt > 0
+}
+
+// buildAndPersistEdges scans all packets in the store, extracts edges per
+// ADVERT/non-ADVERT rules, and persists them to SQLite.
+func buildAndPersistEdges(store *PacketStore, rw *sql.DB) int {
+	store.mu.RLock()
+	packets := make([]*StoreTx, len(store.packets))
+	copy(packets, store.packets)
+	store.mu.RUnlock()
+
+	_, pm := store.getCachedNodesAndPM()
+
+	tx, err := rw.Begin()
+	if err != nil {
+		log.Printf("[neighbor] begin tx error: %v", err)
+		return 0
+	}
+	defer tx.Rollback()
+
+	stmt, err := tx.Prepare(`INSERT INTO neighbor_edges (node_a, node_b, count, last_seen)
+		VALUES (?, ?, 1, ?)
+		ON CONFLICT(node_a, node_b) DO UPDATE SET
+		count = count + 1, last_seen = MAX(last_seen, excluded.last_seen)`)
+	if err != nil {
+		log.Printf("[neighbor] prepare stmt error: %v", err)
+		return 0
+	}
+	defer stmt.Close()
+
+	edgeCount := 0
+	var firstErr error
+	for _, pkt := range packets {
+		for _, obs := range pkt.Observations {
+			for _, ec := range extractEdgesFromObs(obs, pkt, pm) {
+				if _, err := stmt.Exec(ec.A, ec.B, ec.Timestamp); err != nil && firstErr == nil {
+					firstErr = err
+				}
+				edgeCount++
+			}
+		}
+	}
+	if firstErr != nil {
+		log.Printf("[neighbor] edge exec error (first): %v", firstErr)
+	}
+
+	if err := tx.Commit(); err != nil {
+		log.Printf("[neighbor] commit error: %v", err)
+		return 0
+	}
+	return edgeCount
+}
+
+// ─── resolved_path column ──────────────────────────────────────────────────────
+
+// ensureResolvedPathColumn adds the resolved_path column to observations if missing.
+func ensureResolvedPathColumn(dbPath string) error {
+	rw, err := openRW(dbPath)
+	if err != nil {
+		return err
+	}
+	defer rw.Close()
+
+	// Check if column already exists
+	rows, err := rw.Query("PRAGMA table_info(observations)")
+	if err != nil {
+		return err
+	}
+	defer rows.Close()
+
+	for rows.Next() {
+		var cid int
+		var colName string
+		var colType sql.NullString
+		var notNull, pk int
+		var dflt sql.NullString
+		if rows.Scan(&cid, &colName, &colType, &notNull, &dflt, &pk) == nil && colName == "resolved_path" {
+			return nil // already exists
+		}
+	}
+
+	_, err = rw.Exec("ALTER TABLE observations ADD COLUMN resolved_path TEXT")
+	if err != nil {
+		return fmt.Errorf("add resolved_path column: %w", err)
+	}
+	log.Println("[store] Added resolved_path column to observations")
+	return nil
+}
+
+// resolvePathForObs resolves hop prefixes to full pubkeys for an observation.
+// Returns nil if path is empty.
+func resolvePathForObs(pathJSON, observerID string, tx *StoreTx, pm *prefixMap, graph *NeighborGraph) []*string {
+	hops := parsePathJSON(pathJSON)
+	if len(hops) == 0 {
+		return nil
+	}
+
+	// Build context pubkeys: observer + originator (if known)
+	contextPKs := make([]string, 0, 3)
+	if observerID != "" {
+		contextPKs = append(contextPKs, strings.ToLower(observerID))
+	}
+	fromNode := extractFromNode(tx)
+	if fromNode != "" {
+		contextPKs = append(contextPKs, strings.ToLower(fromNode))
+	}
+
+	resolved := make([]*string, len(hops))
+	for i, hop := range hops {
+		// Add adjacent hops as context for disambiguation
+		ctx := make([]string, len(contextPKs), len(contextPKs)+2)
+		copy(ctx, contextPKs)
+		// Add previously resolved hops as context
+		if i > 0 && resolved[i-1] != nil {
+			ctx = append(ctx, *resolved[i-1])
+		}
+
+		node, _, _ := pm.resolveWithContext(hop, ctx, graph)
+		if node != nil {
+			pk := strings.ToLower(node.PublicKey)
+			resolved[i] = &pk
+		}
+	}
+
+	return resolved
+}
+
+// marshalResolvedPath converts []*string to JSON for storage.
+func marshalResolvedPath(rp []*string) string {
+	if len(rp) == 0 {
+		return ""
+	}
+	b, err := json.Marshal(rp)
+	if err != nil {
+		return ""
+	}
+	return string(b)
+}
+
+// unmarshalResolvedPath parses a resolved_path JSON string.
+func unmarshalResolvedPath(s string) []*string {
+	if s == "" {
+		return nil
+	}
+	var result []*string
+	if json.Unmarshal([]byte(s), &result) != nil {
+		return nil
+	}
+	return result
+}
+
+
+// backfillResolvedPathsAsync processes observations with NULL resolved_path in
+// chunks, yielding between batches so HTTP handlers remain responsive. It sets
+// store.backfillComplete when finished and re-picks best observations for any
+// transmissions affected by newly resolved paths.
+func backfillResolvedPathsAsync(store *PacketStore, dbPath string, chunkSize int, yieldDuration time.Duration, backfillHours int) {
+	defer func() {
+		if r := recover(); r != nil {
+			log.Printf("[store] backfillResolvedPathsAsync panic recovered: %v", r)
+		}
+	}()
+	// Collect ALL pending obs refs upfront in one pass under a single RLock (fix A).
+	type obsRef struct {
+		obsID       int
+		pathJSON    string
+		observerID  string
+		txJSON      string
+		payloadType *int
+		txHash      string // to re-pick best obs
+	}
+
+	cutoff := time.Now().UTC().Add(-time.Duration(backfillHours) * time.Hour)
+
+	store.mu.RLock()
+	pm := store.nodePM
+	var allPending []obsRef
+	for _, tx := range store.packets {
+		// Skip transmissions older than the backfill window.
+		if tx.FirstSeen != "" {
+			if ts, err := time.Parse(time.RFC3339Nano, tx.FirstSeen); err == nil && ts.Before(cutoff) {
+				continue
+			}
+			// Also try the common SQLite format
+			if ts, err := time.Parse("2006-01-02 15:04:05", tx.FirstSeen); err == nil && ts.Before(cutoff) {
+				continue
+			}
+		}
+		for _, obs := range tx.Observations {
+			if obs.ResolvedPath == nil && obs.PathJSON != "" && obs.PathJSON != "[]" {
+				allPending = append(allPending, obsRef{
+					obsID:       obs.ID,
+					pathJSON:    obs.PathJSON,
+					observerID:  obs.ObserverID,
+					txJSON:      tx.DecodedJSON,
+					payloadType: tx.PayloadType,
+					txHash:      tx.Hash,
+				})
+			}
+		}
+	}
+	store.mu.RUnlock()
+
+	totalPending := len(allPending)
+	if totalPending == 0 || pm == nil {
+		store.backfillComplete.Store(true)
+		log.Printf("[store] async resolved_path backfill: nothing to do")
+		return
+	}
+
+	store.backfillTotal.Store(int64(totalPending))
+	store.backfillProcessed.Store(0)
+	log.Printf("[store] async resolved_path backfill starting: %d observations", totalPending)
+
+	// Open RW connection once before the chunk loop (fix B).
+	var rw *sql.DB
+	if dbPath != "" {
+		var err error
+		rw, err = openRW(dbPath)
+		if err != nil {
+			log.Printf("[store] async backfill: open rw error: %v", err)
+		}
+	}
+	defer func() {
+		if rw != nil {
+			rw.Close()
+		}
+	}()
+
+	totalProcessed := 0
+	for totalProcessed < totalPending {
+		end := totalProcessed + chunkSize
+		if end > totalPending {
+			end = totalPending
+		}
+		chunk := allPending[totalProcessed:end]
+
+		// Re-read graph under RLock at the start of each chunk so we pick up
+		// a freshly-built graph once the background build goroutine completes,
+		// instead of using the potentially-empty graph captured at cold start.
+		store.mu.RLock()
+		graph := store.graph
+		store.mu.RUnlock()
+
+		// Resolve paths outside any lock.
+		type resolved struct {
+			obsID  int
+			rp     []*string
+			rpJSON string
+			txHash string
+		}
+		var results []resolved
+		for _, ref := range chunk {
+			fakeTx := &StoreTx{DecodedJSON: ref.txJSON, PayloadType: ref.payloadType}
+			rp := resolvePathForObs(ref.pathJSON, ref.observerID, fakeTx, pm, graph)
+			if len(rp) > 0 {
+				rpJSON := marshalResolvedPath(rp)
+				if rpJSON != "" {
+					results = append(results, resolved{ref.obsID, rp, rpJSON, ref.txHash})
+				}
+			}
+		}
+
+		// Persist to SQLite using the shared connection.
+		if len(results) > 0 && rw != nil {
+			sqlTx, err := rw.Begin()
+			if err != nil {
+				log.Printf("[store] async backfill: begin tx error: %v", err)
+			} else {
+				stmt, err := sqlTx.Prepare("UPDATE observations SET resolved_path = ? WHERE id = ?")
+				if err != nil {
+					log.Printf("[store] async backfill: prepare error: %v", err)
+					sqlTx.Rollback()
+				} else {
+					var execErr error
+					for _, r := range results {
+						if _, e := stmt.Exec(r.rpJSON, r.obsID); e != nil && execErr == nil {
+							execErr = e
+						}
+					}
+					if execErr != nil {
+						log.Printf("[store] async backfill: exec error (first): %v", execErr)
+					}
+					stmt.Close()
+					if err := sqlTx.Commit(); err != nil {
+						log.Printf("[store] async backfill: commit error: %v", err)
+					}
+				}
+			}
+
+			// Update in-memory state and re-pick best observation under a single
+			// write lock. The per-tx pickBestObservation is O(observations) which is
+			// typically <10 per tx — negligible cost vs. the race risk of splitting
+			// the lock (pollAndMerge can append to tx.Observations concurrently).
+			store.mu.Lock()
+			affectedSet := make(map[string]bool)
+			for _, r := range results {
+				if obs, ok := store.byObsID[r.obsID]; ok {
+					obs.ResolvedPath = r.rp
+				}
+				if !affectedSet[r.txHash] {
+					affectedSet[r.txHash] = true
+					if tx, ok := store.byHash[r.txHash]; ok {
+						pickBestObservation(tx)
+					}
+				}
+			}
+			store.mu.Unlock()
+		}
+
+		totalProcessed += len(chunk)
+		store.backfillProcessed.Store(int64(totalProcessed))
+		pct := float64(totalProcessed) / float64(totalPending) * 100
+		log.Printf("[store] backfill progress: %d/%d observations (%.1f%%)", totalProcessed, totalPending, pct)
+
+		time.Sleep(yieldDuration)
+	}
+
+	store.backfillComplete.Store(true)
+	log.Printf("[store] async resolved_path backfill complete: %d observations processed", totalProcessed)
+}
+
+// ─── Shared helpers ────────────────────────────────────────────────────────────
+
+// edgeCandidate represents an extracted edge to be persisted.
+type edgeCandidate struct {
+	A, B, Timestamp string
+}
+
+// extractEdgesFromObs extracts neighbor edge candidates from a single observation.
+// For ADVERTs: originator↔path[0] (if unambiguous). For ALL types: observer↔path[last] (if unambiguous).
+// Also handles zero-hop ADVERTs (originator↔observer direct link).
+func extractEdgesFromObs(obs *StoreObs, tx *StoreTx, pm *prefixMap) []edgeCandidate {
+	isAdvert := tx.PayloadType != nil && *tx.PayloadType == 4
+	fromNode := extractFromNode(tx)
+	path := parsePathJSON(obs.PathJSON)
+	observerPK := strings.ToLower(obs.ObserverID)
+	ts := obs.Timestamp
+	var edges []edgeCandidate
+
+	if len(path) == 0 {
+		if isAdvert && fromNode != "" {
+			fromLower := strings.ToLower(fromNode)
+			if fromLower != observerPK {
+				a, b := fromLower, observerPK
+				if a > b {
+					a, b = b, a
+				}
+				edges = append(edges, edgeCandidate{a, b, ts})
+			}
+		}
+		return edges
+	}
+
+	// Edge 1: originator ↔ path[0] — ADVERTs only (resolve prefix to full pubkey)
+	if isAdvert && fromNode != "" && pm != nil {
+		firstHop := strings.ToLower(path[0])
+		fromLower := strings.ToLower(fromNode)
+		candidates := pm.m[firstHop]
+		if len(candidates) == 1 {
+			resolved := strings.ToLower(candidates[0].PublicKey)
+			if resolved != fromLower {
+				a, b := fromLower, resolved
+				if a > b {
+					a, b = b, a
+				}
+				edges = append(edges, edgeCandidate{a, b, ts})
+			}
+		}
+	}
+
+	// Edge 2: observer ↔ path[last] — ALL packet types
+	if pm != nil {
+		lastHop := strings.ToLower(path[len(path)-1])
+		candidates := pm.m[lastHop]
+		if len(candidates) == 1 {
+			resolved := strings.ToLower(candidates[0].PublicKey)
+			if resolved != observerPK {
+				a, b := observerPK, resolved
+				if a > b {
+					a, b = b, a
+				}
+				edges = append(edges, edgeCandidate{a, b, ts})
+			}
+		}
+	}
+
+	return edges
+}
+
+// openRW opens a read-write SQLite connection (same pattern as PruneOldPackets).
+func openRW(dbPath string) (*sql.DB, error) {
+	dsn := fmt.Sprintf("file:%s?_journal_mode=WAL&_busy_timeout=10000", dbPath)
+	rw, err := sql.Open("sqlite", dsn)
+	if err != nil {
+		return nil, err
+	}
+	rw.SetMaxOpenConns(1)
+	return rw, nil
+}
+
+// PruneNeighborEdges removes edges older than maxAgeDays from both SQLite and
+// the in-memory graph. Uses openRW internally because the shared database.conn
+// is opened with mode=ro and DELETEs would silently fail.
+func PruneNeighborEdges(dbPath string, graph *NeighborGraph, maxAgeDays int) (int, error) {
+	cutoff := time.Now().UTC().Add(-time.Duration(maxAgeDays) * 24 * time.Hour)
+
+	// 1. Prune from SQLite using a read-write connection
+	var dbPruned int64
+	rw, err := openRW(dbPath)
+	if err != nil {
+		return 0, fmt.Errorf("prune neighbor_edges: open rw: %w", err)
+	}
+	defer rw.Close()
+	res, err := rw.Exec("DELETE FROM neighbor_edges WHERE last_seen < ?", cutoff.Format(time.RFC3339))
+	if err != nil {
+		return 0, fmt.Errorf("prune neighbor_edges: %w", err)
+	}
+	dbPruned, _ = res.RowsAffected()
+
+	// 2. Prune from in-memory graph
+	memPruned := 0
+	if graph != nil {
+		memPruned = graph.PruneOlderThan(cutoff)
+	}
+
+	if dbPruned > 0 || memPruned > 0 {
+		log.Printf("[neighbor-prune] removed %d DB rows, %d in-memory edges older than %d days", dbPruned, memPruned, maxAgeDays)
+	}
+	return int(dbPruned), nil
+}

cmd/server/neighbor_persist_test.go

@@ -0,0 +1,534 @@
+package main
+
+import (
+	"database/sql"
+	"encoding/json"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+
+	_ "modernc.org/sqlite"
+)
+
+// createTestDBWithSchema creates a temp SQLite DB with the standard schema + resolved_path column.
+func createTestDBWithSchema(t *testing.T) (*DB, string) {
+	t.Helper()
+	dir := t.TempDir()
+	dbPath := filepath.Join(dir, "test.db")
+
+	conn, err := sql.Open("sqlite", "file:"+dbPath+"?_journal_mode=WAL")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Create tables
+	conn.Exec(`CREATE TABLE transmissions (
+		id INTEGER PRIMARY KEY AUTOINCREMENT,
+		raw_hex TEXT, hash TEXT UNIQUE, first_seen TEXT,
+		route_type INTEGER, payload_type INTEGER, payload_version INTEGER,
+		decoded_json TEXT
+	)`)
+	conn.Exec(`CREATE TABLE observers (
+		id TEXT PRIMARY KEY, name TEXT, iata TEXT
+	)`)
+	conn.Exec(`CREATE TABLE observations (
+		id INTEGER PRIMARY KEY AUTOINCREMENT,
+		transmission_id INTEGER NOT NULL REFERENCES transmissions(id),
+		observer_id TEXT, observer_name TEXT, direction TEXT,
+		snr REAL, rssi REAL, score INTEGER,
+		path_json TEXT, timestamp TEXT,
+		resolved_path TEXT
+	)`)
+	conn.Exec(`CREATE TABLE nodes (
+		public_key TEXT PRIMARY KEY, name TEXT, role TEXT,
+		lat REAL, lon REAL, last_seen TEXT, first_seen TEXT,
+		advert_count INTEGER DEFAULT 0
+	)`)
+
+	conn.Close()
+
+	db, err := OpenDB(dbPath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return db, dbPath
+}
+
+func TestResolvePathForObs(t *testing.T) {
+	// Build a prefix map with known nodes
+	nodes := []nodeInfo{
+		{PublicKey: "aabbccddee1234567890aabbccddee1234567890aabbccddee1234567890aabb", Name: "Node-AA"},
+		{PublicKey: "bbccddee1234567890aabbccddee1234567890aabbccddee1234567890aabb11", Name: "Node-BB"},
+	}
+	pm := buildPrefixMap(nodes)
+	graph := NewNeighborGraph()
+
+	tx := &StoreTx{
+		DecodedJSON: `{"pubKey": "originator1234567890"}`,
+		PayloadType: intPtr(4),
+	}
+
+	// Unambiguous prefixes should resolve
+	rp := resolvePathForObs(`["aa","bb"]`, "observer1", tx, pm, graph)
+	if len(rp) != 2 {
+		t.Fatalf("expected 2 resolved hops, got %d", len(rp))
+	}
+	if rp[0] == nil || !strings.HasPrefix(*rp[0], "aabbcc") {
+		t.Errorf("expected first hop to resolve to Node-AA, got %v", rp[0])
+	}
+	if rp[1] == nil || !strings.HasPrefix(*rp[1], "bbccdd") {
+		t.Errorf("expected second hop to resolve to Node-BB, got %v", rp[1])
+	}
+}
+
+func TestResolvePathForObs_EmptyPath(t *testing.T) {
+	pm := buildPrefixMap(nil)
+	rp := resolvePathForObs(`[]`, "", &StoreTx{}, pm, nil)
+	if rp != nil {
+		t.Errorf("expected nil for empty path, got %v", rp)
+	}
+
+	rp = resolvePathForObs("", "", &StoreTx{}, pm, nil)
+	if rp != nil {
+		t.Errorf("expected nil for empty string, got %v", rp)
+	}
+}
+
+func TestResolvePathForObs_Unresolvable(t *testing.T) {
+	nodes := []nodeInfo{
+		{PublicKey: "aabbccddee1234567890aabbccddee1234567890aabbccddee1234567890aabb", Name: "Node-AA"},
+	}
+	pm := buildPrefixMap(nodes)
+
+	// "zz" prefix doesn't match any node
+	rp := resolvePathForObs(`["zz"]`, "", &StoreTx{}, pm, nil)
+	if len(rp) != 1 {
+		t.Fatalf("expected 1 hop, got %d", len(rp))
+	}
+	if rp[0] != nil {
+		t.Errorf("expected nil for unresolvable hop, got %v", *rp[0])
+	}
+}
+
+func TestMarshalUnmarshalResolvedPath(t *testing.T) {
+	pk1 := "aabbccdd"
+	var rp []*string
+	rp = append(rp, &pk1, nil)
+
+	j := marshalResolvedPath(rp)
+	if j == "" {
+		t.Fatal("expected non-empty JSON")
+	}
+
+	parsed := unmarshalResolvedPath(j)
+	if len(parsed) != 2 {
+		t.Fatalf("expected 2 elements, got %d", len(parsed))
+	}
+	if parsed[0] == nil || *parsed[0] != "aabbccdd" {
+		t.Errorf("first element wrong: %v", parsed[0])
+	}
+	if parsed[1] != nil {
+		t.Errorf("second element should be nil, got %v", *parsed[1])
+	}
+}
+
+func TestMarshalResolvedPath_Empty(t *testing.T) {
+	if marshalResolvedPath(nil) != "" {
+		t.Error("expected empty for nil")
+	}
+	if marshalResolvedPath([]*string{}) != "" {
+		t.Error("expected empty for empty slice")
+	}
+}
+
+func TestUnmarshalResolvedPath_Invalid(t *testing.T) {
+	if unmarshalResolvedPath("") != nil {
+		t.Error("expected nil for empty string")
+	}
+	if unmarshalResolvedPath("not json") != nil {
+		t.Error("expected nil for invalid JSON")
+	}
+}
+
+func TestEnsureNeighborEdgesTable(t *testing.T) {
+	dir := t.TempDir()
+	dbPath := filepath.Join(dir, "test.db")
+
+	// Create initial DB
+	conn, _ := sql.Open("sqlite", "file:"+dbPath+"?_journal_mode=WAL")
+	conn.Exec("CREATE TABLE test (id INTEGER PRIMARY KEY)")
+	conn.Close()
+
+	if err := ensureNeighborEdgesTable(dbPath); err != nil {
+		t.Fatal(err)
+	}
+
+	// Verify table exists
+	conn, _ = sql.Open("sqlite", "file:"+dbPath+"?mode=ro")
+	defer conn.Close()
+	var cnt int
+	if err := conn.QueryRow("SELECT COUNT(*) FROM neighbor_edges").Scan(&cnt); err != nil {
+		t.Fatalf("neighbor_edges table not created: %v", err)
+	}
+}
+
+func TestLoadNeighborEdgesFromDB(t *testing.T) {
+	dir := t.TempDir()
+	dbPath := filepath.Join(dir, "test.db")
+
+	conn, _ := sql.Open("sqlite", "file:"+dbPath+"?_journal_mode=WAL")
+	conn.Exec(`CREATE TABLE neighbor_edges (
+		node_a TEXT NOT NULL, node_b TEXT NOT NULL,
+		count INTEGER DEFAULT 1, last_seen TEXT,
+		PRIMARY KEY (node_a, node_b)
+	)`)
+	conn.Exec("INSERT INTO neighbor_edges VALUES ('aaa', 'bbb', 5, '2024-01-01T00:00:00Z')")
+	conn.Exec("INSERT INTO neighbor_edges VALUES ('ccc', 'ddd', 3, '2024-01-02T00:00:00Z')")
+
+	g := loadNeighborEdgesFromDB(conn)
+	conn.Close()
+
+	// Should have 2 edges
+	edges := g.AllEdges()
+	if len(edges) != 2 {
+		t.Errorf("expected 2 edges, got %d", len(edges))
+	}
+
+	// Check neighbors
+	n := g.Neighbors("aaa")
+	if len(n) != 1 {
+		t.Errorf("expected 1 neighbor for aaa, got %d", len(n))
+	}
+}
+
+func TestStoreObsResolvedPathInBroadcast(t *testing.T) {
+	// Verify resolved_path appears in broadcast maps
+	pk := "aabbccdd"
+	obs := &StoreObs{
+		ID:           1,
+		ObserverID:   "obs1",
+		ObserverName: "Observer 1",
+		PathJSON:     `["aa"]`,
+		ResolvedPath: []*string{&pk},
+		Timestamp:    "2024-01-01T00:00:00Z",
+	}
+
+	tx := &StoreTx{
+		ID:   1,
+		Hash: "abc123",
+		Observations: []*StoreObs{obs},
+	}
+	pickBestObservation(tx)
+
+	if tx.ResolvedPath == nil {
+		t.Fatal("expected ResolvedPath to be set on tx after pickBestObservation")
+	}
+	if *tx.ResolvedPath[0] != "aabbccdd" {
+		t.Errorf("expected resolved path to be aabbccdd, got %s", *tx.ResolvedPath[0])
+	}
+}
+
+func TestResolvedPathInTxToMap(t *testing.T) {
+	pk := "aabbccdd"
+	tx := &StoreTx{
+		ID:           1,
+		Hash:         "abc123",
+		PathJSON:     `["aa"]`,
+		ResolvedPath: []*string{&pk},
+		obsKeys:      make(map[string]bool),
+	}
+
+	m := txToMap(tx)
+	rp, ok := m["resolved_path"]
+	if !ok {
+		t.Fatal("resolved_path not in txToMap output")
+	}
+	rpSlice, ok := rp.([]*string)
+	if !ok || len(rpSlice) != 1 || *rpSlice[0] != "aabbccdd" {
+		t.Errorf("unexpected resolved_path: %v", rp)
+	}
+}
+
+func TestResolvedPathOmittedWhenNil(t *testing.T) {
+	tx := &StoreTx{
+		ID:      1,
+		Hash:    "abc123",
+		obsKeys: make(map[string]bool),
+	}
+
+	m := txToMap(tx)
+	if _, ok := m["resolved_path"]; ok {
+		t.Error("resolved_path should not be in map when nil")
+	}
+}
+
+func TestEnsureResolvedPathColumn(t *testing.T) {
+	dir := t.TempDir()
+	dbPath := filepath.Join(dir, "test.db")
+
+	conn, _ := sql.Open("sqlite", "file:"+dbPath+"?_journal_mode=WAL")
+	conn.Exec(`CREATE TABLE observations (
+		id INTEGER PRIMARY KEY, transmission_id INTEGER,
+		observer_id TEXT, path_json TEXT, timestamp TEXT
+	)`)
+	conn.Close()
+
+	if err := ensureResolvedPathColumn(dbPath); err != nil {
+		t.Fatal(err)
+	}
+
+	// Verify column exists
+	conn, _ = sql.Open("sqlite", "file:"+dbPath+"?mode=ro")
+	defer conn.Close()
+	rows, _ := conn.Query("PRAGMA table_info(observations)")
+	found := false
+	for rows.Next() {
+		var cid int
+		var colName string
+		var colType sql.NullString
+		var notNull, pk int
+		var dflt sql.NullString
+		rows.Scan(&cid, &colName, &colType, &notNull, &dflt, &pk)
+		if colName == "resolved_path" {
+			found = true
+		}
+	}
+	rows.Close()
+	if !found {
+		t.Error("resolved_path column not added")
+	}
+
+	// Running again should be idempotent
+	if err := ensureResolvedPathColumn(dbPath); err != nil {
+		t.Fatal("second call should be idempotent:", err)
+	}
+}
+
+func TestDBDetectsResolvedPathColumn(t *testing.T) {
+	dir := t.TempDir()
+	dbPath := filepath.Join(dir, "test.db")
+
+	// Create DB without resolved_path
+	conn, _ := sql.Open("sqlite", "file:"+dbPath+"?_journal_mode=WAL")
+	conn.Exec(`CREATE TABLE observations (id INTEGER PRIMARY KEY, observer_idx INTEGER)`)
+	conn.Exec(`CREATE TABLE transmissions (id INTEGER PRIMARY KEY)`)
+	conn.Close()
+
+	db, err := OpenDB(dbPath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if db.hasResolvedPath {
+		t.Error("should not detect resolved_path when column missing")
+	}
+	db.Close()
+
+	// Add resolved_path column
+	conn, _ = sql.Open("sqlite", "file:"+dbPath+"?_journal_mode=WAL")
+	conn.Exec("ALTER TABLE observations ADD COLUMN resolved_path TEXT")
+	conn.Close()
+
+	db, err = OpenDB(dbPath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !db.hasResolvedPath {
+		t.Error("should detect resolved_path when column exists")
+	}
+	db.Close()
+}
+
+func TestLoadWithResolvedPath(t *testing.T) {
+	db, dbPath := createTestDBWithSchema(t)
+	defer db.Close()
+
+	// Insert test data
+	rw, _ := openRW(dbPath)
+	rw.Exec(`INSERT INTO transmissions (id, hash, first_seen, payload_type, decoded_json)
+		VALUES (1, 'hash1', '2024-01-01T00:00:00Z', 4, '{"pubKey":"origpk"}')`)
+	rw.Exec(`INSERT INTO observations (id, transmission_id, observer_id, observer_name, path_json, timestamp, resolved_path)
+		VALUES (1, 1, 'obs1', 'Observer1', '["aa"]', '2024-01-01T00:00:00Z', '["aabbccdd"]')`)
+	rw.Close()
+
+	store := NewPacketStore(db, nil)
+	if err := store.Load(); err != nil {
+		t.Fatal(err)
+	}
+
+	if len(store.packets) != 1 {
+		t.Fatalf("expected 1 packet, got %d", len(store.packets))
+	}
+
+	tx := store.packets[0]
+	if len(tx.Observations) != 1 {
+		t.Fatalf("expected 1 observation, got %d", len(tx.Observations))
+	}
+
+	obs := tx.Observations[0]
+	if obs.ResolvedPath == nil {
+		t.Fatal("expected ResolvedPath to be loaded")
+	}
+	if len(obs.ResolvedPath) != 1 || *obs.ResolvedPath[0] != "aabbccdd" {
+		t.Errorf("unexpected ResolvedPath: %v", obs.ResolvedPath)
+	}
+
+	// Check that pickBestObservation propagated resolved_path to tx
+	if tx.ResolvedPath == nil || len(tx.ResolvedPath) != 1 {
+		t.Error("expected ResolvedPath to be propagated to tx")
+	}
+}
+
+func TestResolvedPathInAPIResponse(t *testing.T) {
+	// Test that TransmissionResp properly marshals resolved_path
+	pk := "aabbccddee"
+	resp := TransmissionResp{
+		ID:           1,
+		Hash:         "test",
+		ResolvedPath: []*string{&pk, nil},
+	}
+
+	data, err := json.Marshal(resp)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	var m map[string]interface{}
+	json.Unmarshal(data, &m)
+
+	rp, ok := m["resolved_path"]
+	if !ok {
+		t.Fatal("resolved_path missing from JSON")
+	}
+	rpArr, ok := rp.([]interface{})
+	if !ok || len(rpArr) != 2 {
+		t.Fatalf("unexpected resolved_path shape: %v", rp)
+	}
+	if rpArr[0] != "aabbccddee" {
+		t.Errorf("first element wrong: %v", rpArr[0])
+	}
+	if rpArr[1] != nil {
+		t.Errorf("second element should be null: %v", rpArr[1])
+	}
+}
+
+func TestResolvedPathOmittedWhenEmpty(t *testing.T) {
+	resp := TransmissionResp{
+		ID:   1,
+		Hash: "test",
+	}
+
+	data, _ := json.Marshal(resp)
+	var m map[string]interface{}
+	json.Unmarshal(data, &m)
+
+	if _, ok := m["resolved_path"]; ok {
+		t.Error("resolved_path should be omitted when nil")
+	}
+}
+
+func TestExtractEdgesFromObs_AdvertNoPath(t *testing.T) {
+	tx := &StoreTx{
+		DecodedJSON: `{"pubKey":"aaaa1111"}`,
+		PayloadType: intPtr(4),
+	}
+	obs := &StoreObs{
+		ObserverID: "bbbb2222",
+		PathJSON:   "",
+		Timestamp:  "2024-01-01T00:00:00Z",
+	}
+
+	edges := extractEdgesFromObs(obs, tx, nil)
+	if len(edges) != 1 {
+		t.Fatalf("expected 1 edge for zero-hop advert, got %d", len(edges))
+	}
+	// Canonical ordering: aaaa < bbbb
+	if edges[0].A != "aaaa1111" || edges[0].B != "bbbb2222" {
+		t.Errorf("unexpected edge: %+v", edges[0])
+	}
+}
+
+func TestExtractEdgesFromObs_NonAdvertNoPath(t *testing.T) {
+	tx := &StoreTx{PayloadType: intPtr(1)}
+	obs := &StoreObs{ObserverID: "obs1", PathJSON: ""}
+	edges := extractEdgesFromObs(obs, tx, nil)
+	if len(edges) != 0 {
+		t.Errorf("expected 0 edges for non-advert without path, got %d", len(edges))
+	}
+}
+
+func TestExtractEdgesFromObs_WithPath(t *testing.T) {
+	nodes := []nodeInfo{
+		{PublicKey: "aabbccddee1234567890aabbccddee1234567890aabbccddee1234567890aabb", Name: "Node-AA"},
+		{PublicKey: "ffgghhii1234567890aabbccddee1234567890aabbccddee1234567890aabb11", Name: "Node-FF"},
+	}
+	pm := buildPrefixMap(nodes)
+
+	tx := &StoreTx{
+		DecodedJSON: `{"pubKey":"originator00"}`,
+		PayloadType: intPtr(4),
+	}
+	obs := &StoreObs{
+		ObserverID: "observer00",
+		PathJSON:   `["aa","ff"]`,
+		Timestamp:  "2024-01-01T00:00:00Z",
+	}
+
+	edges := extractEdgesFromObs(obs, tx, pm)
+	// Should get: originator↔aa (advert), observer↔ff (last hop)
+	if len(edges) != 2 {
+		t.Fatalf("expected 2 edges, got %d", len(edges))
+	}
+}
+
+func TestExtractEdgesFromObs_SameNodeNoEdge(t *testing.T) {
+	tx := &StoreTx{
+		DecodedJSON: `{"pubKey":"same1234"}`,
+		PayloadType: intPtr(4),
+	}
+	obs := &StoreObs{
+		ObserverID: "same1234",
+		PathJSON:   "",
+		Timestamp:  "2024-01-01T00:00:00Z",
+	}
+	edges := extractEdgesFromObs(obs, tx, nil)
+	if len(edges) != 0 {
+		t.Errorf("expected 0 edges when originator == observer, got %d", len(edges))
+	}
+}
+
+
+
+func TestPersistSemaphoreTryAcquireSkipsBatch(t *testing.T) {
+	// Verify that persistSem is a buffered channel of size 1.
+	if cap(persistSem) != 1 {
+		t.Errorf("persistSem capacity = %d, want 1", cap(persistSem))
+	}
+	// Acquire the semaphore to simulate an in-progress persistence.
+	persistSem <- struct{}{}
+
+	// asyncPersistResolvedPathsAndEdges should skip (not block, not
+	// spawn a goroutine) when the semaphore is already held.
+	done := make(chan struct{})
+	go func() {
+		asyncPersistResolvedPathsAndEdges(
+			"/nonexistent/path.db",
+			[]persistObsUpdate{{obsID: 1, resolvedPath: "x"}},
+			nil,
+			"test",
+		)
+		close(done)
+	}()
+
+	// If the function blocks on the semaphore instead of skipping,
+	// this select will hit the timeout.
+	select {
+	case <-done:
+		// Expected: returned immediately because semaphore was busy.
+	case <-time.After(500 * time.Millisecond):
+		<-persistSem
+		t.Fatal("asyncPersistResolvedPathsAndEdges blocked instead of skipping when semaphore was held")
+	}
+
+	<-persistSem // release
+}

cmd/server/obs_dedup_test.go

@@ -0,0 +1,134 @@
+package main
+
+import (
+	"fmt"
+	"testing"
+)
+
+// TestObsDedupCorrectness verifies that the map-based dedup produces correct
+// results: no duplicate observations (same observerID + pathJSON) on a single
+// transmission.
+func TestObsDedupCorrectness(t *testing.T) {
+	tx := &StoreTx{
+		ID:      1,
+		Hash:    "abc123",
+		obsKeys: make(map[string]bool),
+	}
+
+	// Add 5 unique observations
+	for i := 0; i < 5; i++ {
+		obsID := fmt.Sprintf("obs-%d", i)
+		pathJSON := fmt.Sprintf(`["path-%d"]`, i)
+		dk := obsID + "|" + pathJSON
+		if tx.obsKeys[dk] {
+			t.Fatalf("observation %d should not be a duplicate", i)
+		}
+		tx.Observations = append(tx.Observations, &StoreObs{
+			ID:         i,
+			ObserverID: obsID,
+			PathJSON:   pathJSON,
+		})
+		tx.obsKeys[dk] = true
+		tx.ObservationCount++
+	}
+
+	if tx.ObservationCount != 5 {
+		t.Fatalf("expected 5 observations, got %d", tx.ObservationCount)
+	}
+
+	// Try to add duplicates of each — all should be rejected
+	for i := 0; i < 5; i++ {
+		obsID := fmt.Sprintf("obs-%d", i)
+		pathJSON := fmt.Sprintf(`["path-%d"]`, i)
+		dk := obsID + "|" + pathJSON
+		if !tx.obsKeys[dk] {
+			t.Fatalf("observation %d should be detected as duplicate", i)
+		}
+	}
+
+	// Same observer, different path — should NOT be a duplicate
+	dk := "obs-0" + "|" + `["different-path"]`
+	if tx.obsKeys[dk] {
+		t.Fatal("different path should not be a duplicate")
+	}
+
+	// Different observer, same path — should NOT be a duplicate
+	dk = "obs-new" + "|" + `["path-0"]`
+	if tx.obsKeys[dk] {
+		t.Fatal("different observer should not be a duplicate")
+	}
+}
+
+// TestObsDedupNilMapSafety ensures obsKeys lazy init works for pre-existing
+// transmissions that may not have the map initialized.
+func TestObsDedupNilMapSafety(t *testing.T) {
+	tx := &StoreTx{ID: 1, Hash: "abc"}
+	// obsKeys is nil — the lazy init pattern used in IngestNewFromDB/IngestNewObservations
+	if tx.obsKeys == nil {
+		tx.obsKeys = make(map[string]bool)
+	}
+	dk := "obs1|path1"
+	if tx.obsKeys[dk] {
+		t.Fatal("should not be duplicate on empty map")
+	}
+	tx.obsKeys[dk] = true
+	if !tx.obsKeys[dk] {
+		t.Fatal("should be duplicate after insert")
+	}
+}
+
+// BenchmarkObsDedupMap benchmarks the map-based O(1) dedup approach.
+func BenchmarkObsDedupMap(b *testing.B) {
+	for _, obsCount := range []int{10, 50, 100, 500} {
+		b.Run(fmt.Sprintf("obs=%d", obsCount), func(b *testing.B) {
+			// Pre-populate a tx with obsCount observations
+			tx := &StoreTx{
+				ID:      1,
+				obsKeys: make(map[string]bool),
+			}
+			for i := 0; i < obsCount; i++ {
+				obsID := fmt.Sprintf("obs-%d", i)
+				pathJSON := fmt.Sprintf(`["hop-%d"]`, i)
+				dk := obsID + "|" + pathJSON
+				tx.Observations = append(tx.Observations, &StoreObs{
+					ObserverID: obsID,
+					PathJSON:   pathJSON,
+				})
+				tx.obsKeys[dk] = true
+			}
+
+			// Benchmark: check dedup for a new observation (not duplicate)
+			newDK := "new-obs|new-path"
+			b.ResetTimer()
+			for i := 0; i < b.N; i++ {
+				_ = tx.obsKeys[newDK]
+			}
+		})
+	}
+}
+
+// BenchmarkObsDedupLinear benchmarks the old O(n) linear scan for comparison.
+func BenchmarkObsDedupLinear(b *testing.B) {
+	for _, obsCount := range []int{10, 50, 100, 500} {
+		b.Run(fmt.Sprintf("obs=%d", obsCount), func(b *testing.B) {
+			tx := &StoreTx{ID: 1}
+			for i := 0; i < obsCount; i++ {
+				tx.Observations = append(tx.Observations, &StoreObs{
+					ObserverID: fmt.Sprintf("obs-%d", i),
+					PathJSON:   fmt.Sprintf(`["hop-%d"]`, i),
+				})
+			}
+
+			newObsID := "new-obs"
+			newPath := "new-path"
+			b.ResetTimer()
+			for i := 0; i < b.N; i++ {
+				for _, existing := range tx.Observations {
+					if existing.ObserverID == newObsID && existing.PathJSON == newPath {
+						break
+					}
+				}
+			}
+		})
+	}
+}

cmd/server/openapi.go

@@ -0,0 +1,359 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"sort"
+	"strings"
+
+	"github.com/gorilla/mux"
+)
+
+// routeMeta holds metadata for a single API route.
+type routeMeta struct {
+	Summary     string   `json:"summary"`
+	Description string   `json:"description,omitempty"`
+	Tag         string   `json:"tag"`
+	Auth        bool     `json:"auth,omitempty"`
+	QueryParams []paramMeta `json:"queryParams,omitempty"`
+}
+
+type paramMeta struct {
+	Name        string `json:"name"`
+	Description string `json:"description"`
+	Required    bool   `json:"required,omitempty"`
+	Type        string `json:"type"` // "string", "integer", "boolean"
+}
+
+// routeDescriptions returns metadata for all known API routes.
+// Key format: "METHOD /path/pattern"
+func routeDescriptions() map[string]routeMeta {
+	return map[string]routeMeta{
+		// Config
+		"GET /api/config/cache":      {Summary: "Get cache configuration", Tag: "config"},
+		"GET /api/config/client":     {Summary: "Get client configuration", Tag: "config"},
+		"GET /api/config/regions":    {Summary: "Get configured regions", Tag: "config"},
+		"GET /api/config/theme":      {Summary: "Get theme configuration", Description: "Returns color maps, CSS variables, and theme defaults.", Tag: "config"},
+		"GET /api/config/map":        {Summary: "Get map configuration", Tag: "config"},
+		"GET /api/config/geo-filter": {Summary: "Get geo-filter configuration", Tag: "config"},
+
+		// Admin / system
+		"GET /api/health":     {Summary: "Health check", Description: "Returns server health, uptime, and memory stats.", Tag: "admin"},
+		"GET /api/stats":      {Summary: "Network statistics", Description: "Returns aggregate stats (node counts, packet counts, observer counts). Cached for 10s.", Tag: "admin"},
+		"GET /api/perf":       {Summary: "Performance statistics", Description: "Returns per-endpoint request timing and slow query log.", Tag: "admin"},
+		"POST /api/perf/reset": {Summary: "Reset performance stats", Tag: "admin", Auth: true},
+		"POST /api/admin/prune": {Summary: "Prune old data", Description: "Deletes packets and nodes older than the configured retention period.", Tag: "admin", Auth: true},
+		"GET /api/debug/affinity": {Summary: "Debug neighbor affinity scores", Tag: "admin", Auth: true},
+
+		// Packets
+		"GET /api/packets": {Summary: "List packets", Description: "Returns decoded packets with filtering, sorting, and pagination.", Tag: "packets",
+			QueryParams: []paramMeta{
+				{Name: "limit", Description: "Max packets to return", Type: "integer"},
+				{Name: "offset", Description: "Pagination offset", Type: "integer"},
+				{Name: "sort", Description: "Sort field", Type: "string"},
+				{Name: "order", Description: "Sort order (asc/desc)", Type: "string"},
+				{Name: "type", Description: "Filter by packet type", Type: "string"},
+				{Name: "observer", Description: "Filter by observer ID", Type: "string"},
+				{Name: "timeRange", Description: "Time range filter (e.g. 1h, 24h, 7d)", Type: "string"},
+				{Name: "search", Description: "Full-text search", Type: "string"},
+				{Name: "groupByHash", Description: "Group duplicate packets by hash", Type: "boolean"},
+			}},
+		"POST /api/packets":              {Summary: "Ingest a packet", Description: "Submit a raw packet for decoding and storage.", Tag: "packets", Auth: true},
+		"GET /api/packets/{id}":          {Summary: "Get packet detail", Tag: "packets"},
+		"GET /api/packets/timestamps":    {Summary: "Get packet timestamp ranges", Tag: "packets"},
+		"POST /api/packets/observations": {Summary: "Batch submit observations", Description: "Submit multiple observer sightings for existing packets.", Tag: "packets"},
+
+		// Decode
+		"POST /api/decode": {Summary: "Decode a raw packet", Description: "Decodes a hex-encoded packet without storing it.", Tag: "packets"},
+
+		// Nodes
+		"GET /api/nodes": {Summary: "List nodes", Description: "Returns all known mesh nodes with status and metadata.", Tag: "nodes",
+			QueryParams: []paramMeta{
+				{Name: "role", Description: "Filter by node role", Type: "string"},
+				{Name: "status", Description: "Filter by status (active/stale/offline)", Type: "string"},
+			}},
+		"GET /api/nodes/search":           {Summary: "Search nodes", Description: "Search nodes by name or public key prefix.", Tag: "nodes", QueryParams: []paramMeta{{Name: "q", Description: "Search query", Type: "string", Required: true}}},
+		"GET /api/nodes/bulk-health":       {Summary: "Bulk node health", Description: "Returns health status for all nodes in one call.", Tag: "nodes"},
+		"GET /api/nodes/network-status":    {Summary: "Network status summary", Description: "Returns counts of active, stale, and offline nodes.", Tag: "nodes"},
+		"GET /api/nodes/{pubkey}":          {Summary: "Get node detail", Description: "Returns full detail for a single node by public key.", Tag: "nodes"},
+		"GET /api/nodes/{pubkey}/health":   {Summary: "Get node health", Tag: "nodes"},
+		"GET /api/nodes/{pubkey}/paths":    {Summary: "Get node routing paths", Tag: "nodes"},
+		"GET /api/nodes/{pubkey}/analytics": {Summary: "Get node analytics", Description: "Per-node packet counts, timing, and RF stats.", Tag: "nodes"},
+		"GET /api/nodes/{pubkey}/neighbors": {Summary: "Get node neighbors", Description: "Returns neighbor nodes with affinity scores.", Tag: "nodes"},
+
+		// Analytics
+		"GET /api/analytics/rf":               {Summary: "RF analytics", Description: "SNR/RSSI distributions and statistics.", Tag: "analytics"},
+		"GET /api/analytics/topology":          {Summary: "Network topology", Description: "Hop-count distribution and route analysis.", Tag: "analytics"},
+		"GET /api/analytics/channels":          {Summary: "Channel analytics", Description: "Message counts and activity per channel.", Tag: "analytics"},
+		"GET /api/analytics/distance":          {Summary: "Distance analytics", Description: "Geographic distance calculations between nodes.", Tag: "analytics"},
+		"GET /api/analytics/hash-sizes":        {Summary: "Hash size analysis", Description: "Distribution of hash prefix sizes across the network.", Tag: "analytics"},
+		"GET /api/analytics/hash-collisions":   {Summary: "Hash collision detection", Description: "Identifies nodes sharing hash prefixes.", Tag: "analytics"},
+		"GET /api/analytics/subpaths":          {Summary: "Subpath analysis", Description: "Common routing subpaths through the mesh.", Tag: "analytics"},
+		"GET /api/analytics/subpaths-bulk":     {Summary: "Bulk subpath analysis", Tag: "analytics"},
+		"GET /api/analytics/subpath-detail":    {Summary: "Subpath detail", Tag: "analytics"},
+		"GET /api/analytics/neighbor-graph":    {Summary: "Neighbor graph", Description: "Full neighbor affinity graph for visualization.", Tag: "analytics"},
+
+		// Channels
+		"GET /api/channels":                 {Summary: "List channels", Description: "Returns known mesh channels with message counts.", Tag: "channels"},
+		"GET /api/channels/{hash}/messages": {Summary: "Get channel messages", Description: "Returns messages for a specific channel.", Tag: "channels"},
+
+		// Observers
+		"GET /api/observers":                    {Summary: "List observers", Description: "Returns all known packet observers/gateways.", Tag: "observers"},
+		"GET /api/observers/{id}":               {Summary: "Get observer detail", Tag: "observers"},
+		"GET /api/observers/{id}/metrics":       {Summary: "Get observer metrics", Description: "Packet rates, uptime, and performance metrics.", Tag: "observers"},
+		"GET /api/observers/{id}/analytics":     {Summary: "Get observer analytics", Tag: "observers"},
+		"GET /api/observers/metrics/summary":    {Summary: "Observer metrics summary", Description: "Aggregate metrics across all observers.", Tag: "observers"},
+
+		// Misc
+		"GET /api/resolve-hops":      {Summary: "Resolve hop path", Description: "Resolves hash prefixes in a hop path to node names. Returns affinity scores and best candidates.", Tag: "nodes", QueryParams: []paramMeta{{Name: "hops", Description: "Comma-separated hop hash prefixes", Type: "string", Required: true}}},
+		"GET /api/traces/{hash}":     {Summary: "Get packet traces", Description: "Returns all observer sightings for a packet hash.", Tag: "packets"},
+		"GET /api/iata-coords":       {Summary: "Get IATA airport coordinates", Description: "Returns lat/lon for known airport codes (used for observer positioning).", Tag: "config"},
+		"GET /api/audio-lab/buckets": {Summary: "Audio lab frequency buckets", Description: "Returns frequency bucket data for audio analysis.", Tag: "analytics"},
+	}
+}
+
+// buildOpenAPISpec constructs an OpenAPI 3.0 spec by walking the mux router.
+func buildOpenAPISpec(router *mux.Router, version string) map[string]interface{} {
+	descriptions := routeDescriptions()
+
+	// Collect routes from the router
+	type routeInfo struct {
+		path    string
+		method  string
+		authReq bool
+	}
+	var routes []routeInfo
+
+	router.Walk(func(route *mux.Route, router *mux.Router, ancestors []*mux.Route) error {
+		path, err := route.GetPathTemplate()
+		if err != nil {
+			return nil
+		}
+		if !strings.HasPrefix(path, "/api/") {
+			return nil
+		}
+		// Skip the spec/docs endpoints themselves
+		if path == "/api/spec" || path == "/api/docs" {
+			return nil
+		}
+		methods, err := route.GetMethods()
+		if err != nil {
+			return nil
+		}
+		for _, m := range methods {
+			routes = append(routes, routeInfo{path: path, method: m})
+		}
+		return nil
+	})
+
+	// Sort routes for deterministic output
+	sort.Slice(routes, func(i, j int) bool {
+		if routes[i].path != routes[j].path {
+			return routes[i].path < routes[j].path
+		}
+		return routes[i].method < routes[j].method
+	})
+
+	// Build paths object
+	paths := make(map[string]interface{})
+	tagSet := make(map[string]bool)
+
+	for _, ri := range routes {
+		key := ri.method + " " + ri.path
+		meta, hasMeta := descriptions[key]
+
+		// Convert mux path params {name} to OpenAPI {name} (same format, convenient)
+		openAPIPath := ri.path
+
+		// Build operation
+		op := map[string]interface{}{
+			"summary": func() string {
+				if hasMeta {
+					return meta.Summary
+				}
+				return ri.path
+			}(),
+			"responses": map[string]interface{}{
+				"200": map[string]interface{}{
+					"description": "Success",
+					"content": map[string]interface{}{
+						"application/json": map[string]interface{}{
+							"schema": map[string]interface{}{"type": "object"},
+						},
+					},
+				},
+			},
+		}
+
+		if hasMeta {
+			if meta.Description != "" {
+				op["description"] = meta.Description
+			}
+			if meta.Tag != "" {
+				op["tags"] = []string{meta.Tag}
+				tagSet[meta.Tag] = true
+			}
+			if meta.Auth {
+				op["security"] = []map[string]interface{}{
+					{"ApiKeyAuth": []string{}},
+				}
+			}
+
+			// Add query parameters
+			if len(meta.QueryParams) > 0 {
+				params := make([]interface{}, 0, len(meta.QueryParams))
+				for _, qp := range meta.QueryParams {
+					p := map[string]interface{}{
+						"name":     qp.Name,
+						"in":       "query",
+						"required": qp.Required,
+						"schema":   map[string]interface{}{"type": qp.Type},
+					}
+					if qp.Description != "" {
+						p["description"] = qp.Description
+					}
+					params = append(params, p)
+				}
+				op["parameters"] = params
+			}
+		}
+
+		// Extract path parameters from {name} patterns
+		pathParams := extractPathParams(openAPIPath)
+		if len(pathParams) > 0 {
+			existing, _ := op["parameters"].([]interface{})
+			for _, pp := range pathParams {
+				existing = append(existing, map[string]interface{}{
+					"name":     pp,
+					"in":       "path",
+					"required": true,
+					"schema":   map[string]interface{}{"type": "string"},
+				})
+			}
+			op["parameters"] = existing
+		}
+
+		// Add to paths
+		methodLower := strings.ToLower(ri.method)
+		if _, ok := paths[openAPIPath]; !ok {
+			paths[openAPIPath] = make(map[string]interface{})
+		}
+		paths[openAPIPath].(map[string]interface{})[methodLower] = op
+	}
+
+	// Build tags array (sorted)
+	tagOrder := []string{"admin", "analytics", "channels", "config", "nodes", "observers", "packets"}
+	tagDescriptions := map[string]string{
+		"admin":     "Server administration and diagnostics",
+		"analytics": "Network analytics and statistics",
+		"channels":  "Mesh channel operations",
+		"config":    "Server configuration",
+		"nodes":     "Mesh node operations",
+		"observers": "Packet observer/gateway operations",
+		"packets":   "Packet capture and decoding",
+	}
+	var tags []interface{}
+	for _, t := range tagOrder {
+		if tagSet[t] {
+			tags = append(tags, map[string]interface{}{
+				"name":        t,
+				"description": tagDescriptions[t],
+			})
+		}
+	}
+
+	spec := map[string]interface{}{
+		"openapi": "3.0.3",
+		"info": map[string]interface{}{
+			"title":       "CoreScope API",
+			"description": "MeshCore network analyzer — packet capture, node tracking, and mesh analytics.",
+			"version":     version,
+			"license": map[string]interface{}{
+				"name": "MIT",
+			},
+		},
+		"paths": paths,
+		"tags":  tags,
+		"components": map[string]interface{}{
+			"securitySchemes": map[string]interface{}{
+				"ApiKeyAuth": map[string]interface{}{
+					"type": "apiKey",
+					"in":   "header",
+					"name": "X-API-Key",
+				},
+			},
+		},
+	}
+
+	return spec
+}
+
+// extractPathParams returns parameter names from a mux-style path like /api/nodes/{pubkey}.
+func extractPathParams(path string) []string {
+	var params []string
+	for {
+		start := strings.Index(path, "{")
+		if start == -1 {
+			break
+		}
+		end := strings.Index(path[start:], "}")
+		if end == -1 {
+			break
+		}
+		params = append(params, path[start+1:start+end])
+		path = path[start+end+1:]
+	}
+	return params
+}
+
+// handleOpenAPISpec serves the OpenAPI 3.0 spec as JSON.
+// The router is injected via RegisterRoutes storing it on the Server.
+func (s *Server) handleOpenAPISpec(w http.ResponseWriter, r *http.Request) {
+	spec := buildOpenAPISpec(s.router, s.version)
+
+	w.Header().Set("Content-Type", "application/json; charset=utf-8")
+	w.Header().Set("Access-Control-Allow-Origin", "*")
+	enc := json.NewEncoder(w)
+	enc.SetIndent("", "  ")
+	if err := enc.Encode(spec); err != nil {
+		http.Error(w, fmt.Sprintf("failed to encode spec: %v", err), http.StatusInternalServerError)
+	}
+}
+
+// handleSwaggerUI serves a minimal Swagger UI page.
+func (s *Server) handleSwaggerUI(w http.ResponseWriter, r *http.Request) {
+	w.Header().Set("Content-Type", "text/html; charset=utf-8")
+	fmt.Fprint(w, swaggerUIHTML)
+}
+
+const swaggerUIHTML = `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <title>CoreScope API — Swagger UI</title>
+  <link rel="stylesheet" href="https://unpkg.com/swagger-ui-dist@5/swagger-ui.css">
+  <style>
+    html { box-sizing: border-box; overflow-y: scroll; }
+    *, *:before, *:after { box-sizing: inherit; }
+    body { margin: 0; background: #fafafa; }
+    .topbar { display: none; }
+  </style>
+</head>
+<body>
+  <div id="swagger-ui"></div>
+  <script src="https://unpkg.com/swagger-ui-dist@5/swagger-ui-bundle.js"></script>
+  <script>
+    SwaggerUIBundle({
+      url: '/api/spec',
+      dom_id: '#swagger-ui',
+      deepLinking: true,
+      presets: [
+        SwaggerUIBundle.presets.apis,
+        SwaggerUIBundle.SwaggerUIStandalonePreset
+      ],
+      layout: 'BaseLayout'
+    });
+  </script>
+</body>
+</html>`

cmd/server/openapi_test.go

@@ -0,0 +1,142 @@
+package main
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+)
+
+func TestOpenAPISpecEndpoint(t *testing.T) {
+	_, r := setupTestServer(t)
+
+	req := httptest.NewRequest("GET", "/api/spec", nil)
+	w := httptest.NewRecorder()
+	r.ServeHTTP(w, req)
+
+	if w.Code != http.StatusOK {
+		t.Fatalf("expected 200, got %d", w.Code)
+	}
+
+	ct := w.Header().Get("Content-Type")
+	if ct != "application/json; charset=utf-8" {
+		t.Errorf("unexpected content-type: %s", ct)
+	}
+
+	var spec map[string]interface{}
+	if err := json.Unmarshal(w.Body.Bytes(), &spec); err != nil {
+		t.Fatalf("invalid JSON: %v", err)
+	}
+
+	// Check required OpenAPI fields
+	if spec["openapi"] != "3.0.3" {
+		t.Errorf("expected openapi 3.0.3, got %v", spec["openapi"])
+	}
+
+	info, ok := spec["info"].(map[string]interface{})
+	if !ok {
+		t.Fatal("missing info object")
+	}
+	if info["title"] != "CoreScope API" {
+		t.Errorf("unexpected title: %v", info["title"])
+	}
+
+	paths, ok := spec["paths"].(map[string]interface{})
+	if !ok {
+		t.Fatal("missing paths object")
+	}
+
+	// Should have at least 20 paths
+	if len(paths) < 20 {
+		t.Errorf("expected at least 20 paths, got %d", len(paths))
+	}
+
+	// Check a known path exists
+	if _, ok := paths["/api/nodes"]; !ok {
+		t.Error("missing /api/nodes path")
+	}
+	if _, ok := paths["/api/packets"]; !ok {
+		t.Error("missing /api/packets path")
+	}
+
+	// Check tags exist
+	tags, ok := spec["tags"].([]interface{})
+	if !ok || len(tags) == 0 {
+		t.Error("missing or empty tags")
+	}
+
+	// Check security schemes
+	components, ok := spec["components"].(map[string]interface{})
+	if !ok {
+		t.Fatal("missing components")
+	}
+	schemes, ok := components["securitySchemes"].(map[string]interface{})
+	if !ok {
+		t.Fatal("missing securitySchemes")
+	}
+	if _, ok := schemes["ApiKeyAuth"]; !ok {
+		t.Error("missing ApiKeyAuth security scheme")
+	}
+
+	// Spec should NOT contain /api/spec or /api/docs (self-referencing)
+	if _, ok := paths["/api/spec"]; ok {
+		t.Error("/api/spec should not appear in the spec")
+	}
+	if _, ok := paths["/api/docs"]; ok {
+		t.Error("/api/docs should not appear in the spec")
+	}
+}
+
+func TestSwaggerUIEndpoint(t *testing.T) {
+	_, r := setupTestServer(t)
+
+	req := httptest.NewRequest("GET", "/api/docs", nil)
+	w := httptest.NewRecorder()
+	r.ServeHTTP(w, req)
+
+	if w.Code != http.StatusOK {
+		t.Fatalf("expected 200, got %d", w.Code)
+	}
+
+	ct := w.Header().Get("Content-Type")
+	if ct != "text/html; charset=utf-8" {
+		t.Errorf("unexpected content-type: %s", ct)
+	}
+
+	body := w.Body.String()
+	if len(body) < 100 {
+		t.Error("response too short for Swagger UI HTML")
+	}
+	if !strings.Contains(body, "swagger-ui") {
+		t.Error("response doesn't contain swagger-ui reference")
+	}
+	if !strings.Contains(body, "/api/spec") {
+		t.Error("response doesn't point to /api/spec")
+	}
+}
+
+func TestExtractPathParams(t *testing.T) {
+	tests := []struct {
+		path   string
+		expect []string
+	}{
+		{"/api/nodes", nil},
+		{"/api/nodes/{pubkey}", []string{"pubkey"}},
+		{"/api/channels/{hash}/messages", []string{"hash"}},
+	}
+	for _, tt := range tests {
+		got := extractPathParams(tt.path)
+		if len(got) != len(tt.expect) {
+			t.Errorf("extractPathParams(%q) = %v, want %v", tt.path, got, tt.expect)
+			continue
+		}
+		for i := range got {
+			if got[i] != tt.expect[i] {
+				t.Errorf("extractPathParams(%q)[%d] = %q, want %q", tt.path, i, got[i], tt.expect[i])
+			}
+		}
+	}
+}
+
+

cmd/server/resolve_context_test.go

@@ -0,0 +1,309 @@
+package main
+
+import (
+	"encoding/json"
+	"net/http/httptest"
+	"testing"
+	"time"
+)
+
+// ─── resolveWithContext unit tests ─────────────────────────────────────────────
+
+func TestResolveWithContext_UniquePrefix(t *testing.T) {
+	pm := buildPrefixMap([]nodeInfo{
+		{PublicKey: "a1b2c3d4", Name: "Node-A", HasGPS: true, Lat: 1, Lon: 2},
+	})
+	ni, confidence, _ := pm.resolveWithContext("a1b2c3d4", nil, nil)
+	if ni == nil || ni.Name != "Node-A" {
+		t.Fatal("expected Node-A")
+	}
+	if confidence != "unique_prefix" {
+		t.Fatalf("expected unique_prefix, got %s", confidence)
+	}
+}
+
+func TestResolveWithContext_NoMatch(t *testing.T) {
+	pm := buildPrefixMap([]nodeInfo{
+		{PublicKey: "a1b2c3d4", Name: "Node-A"},
+	})
+	ni, confidence, _ := pm.resolveWithContext("ff", nil, nil)
+	if ni != nil {
+		t.Fatal("expected nil")
+	}
+	if confidence != "no_match" {
+		t.Fatalf("expected no_match, got %s", confidence)
+	}
+}
+
+func TestResolveWithContext_AffinityWins(t *testing.T) {
+	pm := buildPrefixMap([]nodeInfo{
+		{PublicKey: "a1aaaaaa", Name: "Node-A1"},
+		{PublicKey: "a1bbbbbb", Name: "Node-A2"},
+	})
+
+	graph := NewNeighborGraph()
+	for i := 0; i < 100; i++ {
+		graph.upsertEdge("c0c0c0c0", "a1aaaaaa", "a1", "obs1", nil, time.Now())
+	}
+
+	ni, confidence, score := pm.resolveWithContext("a1", []string{"c0c0c0c0"}, graph)
+	if ni == nil || ni.Name != "Node-A1" {
+		t.Fatalf("expected Node-A1, got %v", ni)
+	}
+	if confidence != "neighbor_affinity" {
+		t.Fatalf("expected neighbor_affinity, got %s", confidence)
+	}
+	if score <= 0 {
+		t.Fatalf("expected positive score, got %f", score)
+	}
+}
+
+func TestResolveWithContext_AffinityTooClose_FallsToGeo(t *testing.T) {
+	pm := buildPrefixMap([]nodeInfo{
+		{PublicKey: "a1aaaaaa", Name: "Node-A1", HasGPS: true, Lat: 10, Lon: 20},
+		{PublicKey: "a1bbbbbb", Name: "Node-A2", HasGPS: true, Lat: 11, Lon: 21},
+		{PublicKey: "c0c0c0c0", Name: "Ctx", HasGPS: true, Lat: 10.1, Lon: 20.1},
+	})
+
+	graph := NewNeighborGraph()
+	for i := 0; i < 50; i++ {
+		graph.upsertEdge("c0c0c0c0", "a1aaaaaa", "a1", "obs1", nil, time.Now())
+		graph.upsertEdge("c0c0c0c0", "a1bbbbbb", "a1", "obs1", nil, time.Now())
+	}
+
+	ni, confidence, _ := pm.resolveWithContext("a1", []string{"c0c0c0c0"}, graph)
+	if ni == nil {
+		t.Fatal("expected a result")
+	}
+	if confidence != "geo_proximity" {
+		t.Fatalf("expected geo_proximity, got %s", confidence)
+	}
+	if ni.Name != "Node-A1" {
+		t.Fatalf("expected Node-A1 (closer to context), got %s", ni.Name)
+	}
+}
+
+func TestResolveWithContext_GPSPreference(t *testing.T) {
+	pm := buildPrefixMap([]nodeInfo{
+		{PublicKey: "a1aaaaaa", Name: "NoGPS"},
+		{PublicKey: "a1bbbbbb", Name: "HasGPS", HasGPS: true, Lat: 1, Lon: 2},
+	})
+
+	ni, confidence, _ := pm.resolveWithContext("a1", nil, nil)
+	if ni == nil || ni.Name != "HasGPS" {
+		t.Fatalf("expected HasGPS, got %v", ni)
+	}
+	if confidence != "gps_preference" {
+		t.Fatalf("expected gps_preference, got %s", confidence)
+	}
+}
+
+func TestResolveWithContext_FirstMatchFallback(t *testing.T) {
+	pm := buildPrefixMap([]nodeInfo{
+		{PublicKey: "a1aaaaaa", Name: "First"},
+		{PublicKey: "a1bbbbbb", Name: "Second"},
+	})
+
+	ni, confidence, _ := pm.resolveWithContext("a1", nil, nil)
+	if ni == nil || ni.Name != "First" {
+		t.Fatalf("expected First, got %v", ni)
+	}
+	if confidence != "first_match" {
+		t.Fatalf("expected first_match, got %s", confidence)
+	}
+}
+
+func TestResolveWithContext_NilGraphFallsToGPS(t *testing.T) {
+	pm := buildPrefixMap([]nodeInfo{
+		{PublicKey: "a1aaaaaa", Name: "NoGPS"},
+		{PublicKey: "a1bbbbbb", Name: "HasGPS", HasGPS: true, Lat: 1, Lon: 2},
+	})
+
+	ni, confidence, _ := pm.resolveWithContext("a1", []string{"someone"}, nil)
+	if ni == nil || ni.Name != "HasGPS" {
+		t.Fatalf("expected HasGPS, got %v", ni)
+	}
+	if confidence != "gps_preference" {
+		t.Fatalf("expected gps_preference, got %s", confidence)
+	}
+}
+
+func TestResolveWithContext_BackwardCompatResolve(t *testing.T) {
+	// Verify original resolve() still works unchanged
+	pm := buildPrefixMap([]nodeInfo{
+		{PublicKey: "a1aaaaaa", Name: "NoGPS"},
+		{PublicKey: "a1bbbbbb", Name: "HasGPS", HasGPS: true, Lat: 1, Lon: 2},
+	})
+	ni := pm.resolve("a1")
+	if ni == nil || ni.Name != "HasGPS" {
+		t.Fatalf("expected HasGPS from resolve(), got %v", ni)
+	}
+}
+
+// ─── geoDistApprox ─────────────────────────────────────────────────────────────
+
+func TestGeoDistApprox_SamePoint(t *testing.T) {
+	d := geoDistApprox(37.0, -122.0, 37.0, -122.0)
+	if d != 0 {
+		t.Fatalf("expected 0, got %f", d)
+	}
+}
+
+func TestGeoDistApprox_Ordering(t *testing.T) {
+	d1 := geoDistApprox(37.0, -122.0, 37.01, -122.01)
+	d2 := geoDistApprox(37.0, -122.0, 38.0, -121.0)
+	if d1 >= d2 {
+		t.Fatal("closer point should have smaller distance")
+	}
+}
+
+// ─── handleResolveHops enhanced response (API tests) ───────────────────────────
+
+func TestResolveHopsAPI_UniquePrefix(t *testing.T) {
+	srv, router := setupTestServer(t)
+	_ = srv
+
+	// Insert a unique node
+	srv.db.conn.Exec("INSERT OR IGNORE INTO nodes (public_key, name, lat, lon) VALUES (?, ?, ?, ?)",
+		"ff11223344", "UniqueNode", 37.0, -122.0)
+	srv.store.InvalidateNodeCache()
+
+	req := httptest.NewRequest("GET", "/api/resolve-hops?hops=ff11223344", nil)
+	rr := httptest.NewRecorder()
+	router.ServeHTTP(rr, req)
+
+	var result ResolveHopsResponse
+	if err := json.Unmarshal(rr.Body.Bytes(), &result); err != nil {
+		t.Fatalf("bad JSON: %v", err)
+	}
+
+	hr, ok := result.Resolved["ff11223344"]
+	if !ok {
+		t.Fatal("expected hop in resolved map")
+	}
+	if hr.Confidence != "unique_prefix" {
+		t.Fatalf("expected unique_prefix, got %s", hr.Confidence)
+	}
+}
+
+func TestResolveHopsAPI_AmbiguousNoContext(t *testing.T) {
+	srv, router := setupTestServer(t)
+
+	srv.db.conn.Exec("INSERT OR IGNORE INTO nodes (public_key, name, lat, lon) VALUES (?, ?, ?, ?)",
+		"ee1aaaaaaa", "Node-E1", 37.0, -122.0)
+	srv.db.conn.Exec("INSERT OR IGNORE INTO nodes (public_key, name, lat, lon) VALUES (?, ?, ?, ?)",
+		"ee1bbbbbbb", "Node-E2", 38.0, -121.0)
+	srv.store.InvalidateNodeCache()
+
+	req := httptest.NewRequest("GET", "/api/resolve-hops?hops=ee1", nil)
+	rr := httptest.NewRecorder()
+	router.ServeHTTP(rr, req)
+
+	var result ResolveHopsResponse
+	json.Unmarshal(rr.Body.Bytes(), &result)
+
+	hr := result.Resolved["ee1"]
+	if hr == nil {
+		t.Fatal("expected hop in resolved map")
+	}
+	// With both candidates having GPS and no affinity context, the resolver
+	// picks the GPS-preferred candidate → confidence is "gps_preference".
+	if hr.Confidence != "gps_preference" {
+		t.Fatalf("expected gps_preference, got %s", hr.Confidence)
+	}
+	if len(hr.Candidates) != 2 {
+		t.Fatalf("expected 2 candidates, got %d", len(hr.Candidates))
+	}
+	for _, c := range hr.Candidates {
+		if c.AffinityScore != nil {
+			t.Fatal("expected nil affinity score without context")
+		}
+	}
+}
+
+func TestResolveHopsAPI_WithAffinityContext(t *testing.T) {
+	srv, router := setupTestServer(t)
+
+	srv.db.conn.Exec("INSERT OR IGNORE INTO nodes (public_key, name, lat, lon) VALUES (?, ?, ?, ?)",
+		"dd1aaaaaaa", "Node-D1", 37.0, -122.0)
+	srv.db.conn.Exec("INSERT OR IGNORE INTO nodes (public_key, name, lat, lon) VALUES (?, ?, ?, ?)",
+		"dd1bbbbbbb", "Node-D2", 38.0, -121.0)
+	srv.db.conn.Exec("INSERT OR IGNORE INTO nodes (public_key, name, lat, lon) VALUES (?, ?, ?, ?)",
+		"c0c0c0c0c0", "Context", 37.1, -122.1)
+
+	// Invalidate node cache so the PM includes newly inserted nodes.
+	srv.store.cacheMu.Lock()
+	srv.store.nodeCacheTime = time.Time{}
+	srv.store.cacheMu.Unlock()
+
+	// Build graph with strong affinity
+	graph := NewNeighborGraph()
+	for i := 0; i < 100; i++ {
+		graph.upsertEdge("c0c0c0c0c0", "dd1aaaaaaa", "dd1", "obs1", nil, time.Now())
+	}
+	graph.builtAt = time.Now()
+	srv.neighborMu.Lock()
+	srv.neighborGraph = graph
+	srv.neighborMu.Unlock()
+
+	req := httptest.NewRequest("GET", "/api/resolve-hops?hops=dd1&from_node=c0c0c0c0c0", nil)
+	rr := httptest.NewRecorder()
+	router.ServeHTTP(rr, req)
+
+	var result ResolveHopsResponse
+	json.Unmarshal(rr.Body.Bytes(), &result)
+
+	hr := result.Resolved["dd1"]
+	if hr == nil {
+		t.Fatal("expected hop in resolved map")
+	}
+	if hr.Confidence != "neighbor_affinity" {
+		t.Fatalf("expected neighbor_affinity, got %s", hr.Confidence)
+	}
+	if hr.BestCandidate == nil || *hr.BestCandidate != "dd1aaaaaaa" {
+		t.Fatalf("expected bestCandidate dd1aaaaaaa, got %v", hr.BestCandidate)
+	}
+
+	// Verify affinity scores present
+	hasScore := false
+	for _, c := range hr.Candidates {
+		if c.AffinityScore != nil && *c.AffinityScore > 0 {
+			hasScore = true
+		}
+	}
+	if !hasScore {
+		t.Fatal("expected at least one candidate with affinity score")
+	}
+}
+
+func TestResolveHopsAPI_ResponseShape(t *testing.T) {
+	srv, router := setupTestServer(t)
+
+	srv.db.conn.Exec("INSERT OR IGNORE INTO nodes (public_key, name, lat, lon) VALUES (?, ?, ?, ?)",
+		"bb1aaaaaaa", "Node-B1", 37.0, -122.0)
+
+	req := httptest.NewRequest("GET", "/api/resolve-hops?hops=bb1a", nil)
+	rr := httptest.NewRecorder()
+	router.ServeHTTP(rr, req)
+
+	var raw map[string]json.RawMessage
+	json.Unmarshal(rr.Body.Bytes(), &raw)
+
+	if _, ok := raw["resolved"]; !ok {
+		t.Fatal("missing 'resolved' key")
+	}
+
+	var resolved map[string]map[string]interface{}
+	json.Unmarshal(raw["resolved"], &resolved)
+
+	for _, hr := range resolved {
+		if _, ok := hr["confidence"]; !ok {
+			t.Error("missing 'confidence' field in HopResolution")
+		}
+		if _, ok := hr["candidates"]; !ok {
+			t.Error("missing 'candidates' field")
+		}
+	}
+}
+
+// ─── Helpers used only in this test file ───────────────────────────────────────

cmd/server/routes.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+	"crypto/subtle"
 	"database/sql"
 	"encoding/json"
 	"fmt"
@@ -38,6 +39,13 @@ type Server struct {
 	statsMu      sync.Mutex
 	statsCache   *StatsResponse
 	statsCachedAt time.Time
+
+	// Neighbor affinity graph (lazy-built, cached with TTL)
+	neighborMu    sync.Mutex
+	neighborGraph *NeighborGraph
+
+	// Router reference for OpenAPI spec generation
+	router *mux.Router
 }
 
 // PerfStats tracks request performance.
@@ -94,9 +102,13 @@ func (s *Server) getMemStats() runtime.MemStats {
 
 // RegisterRoutes sets up all HTTP routes on the given router.
 func (s *Server) RegisterRoutes(r *mux.Router) {
+	s.router = r
 	// Performance instrumentation middleware
 	r.Use(s.perfMiddleware)
 
+	// Backfill status header middleware
+	r.Use(s.backfillStatusMiddleware)
+
 	// Config endpoints
 	r.HandleFunc("/api/config/cache", s.handleConfigCache).Methods("GET")
 	r.HandleFunc("/api/config/client", s.handleConfigClient).Methods("GET")
@@ -111,8 +123,10 @@ func (s *Server) RegisterRoutes(r *mux.Router) {
 	r.HandleFunc("/api/perf", s.handlePerf).Methods("GET")
 	r.Handle("/api/perf/reset", s.requireAPIKey(http.HandlerFunc(s.handlePerfReset))).Methods("POST")
 	r.Handle("/api/admin/prune", s.requireAPIKey(http.HandlerFunc(s.handleAdminPrune))).Methods("POST")
+	r.Handle("/api/debug/affinity", s.requireAPIKey(http.HandlerFunc(s.handleDebugAffinity))).Methods("GET")
 
 	// Packet endpoints
+	r.HandleFunc("/api/packets/observations", s.handleBatchObservations).Methods("POST")
 	r.HandleFunc("/api/packets/timestamps", s.handlePacketTimestamps).Methods("GET")
 	r.HandleFunc("/api/packets/{id}", s.handlePacketDetail).Methods("GET")
 	r.HandleFunc("/api/packets", s.handlePackets).Methods("GET")
@@ -128,6 +142,7 @@ func (s *Server) RegisterRoutes(r *mux.Router) {
 	r.HandleFunc("/api/nodes/{pubkey}/health", s.handleNodeHealth).Methods("GET")
 	r.HandleFunc("/api/nodes/{pubkey}/paths", s.handleNodePaths).Methods("GET")
 	r.HandleFunc("/api/nodes/{pubkey}/analytics", s.handleNodeAnalytics).Methods("GET")
+	r.HandleFunc("/api/nodes/{pubkey}/neighbors", s.handleNodeNeighbors).Methods("GET")
 	r.HandleFunc("/api/nodes/{pubkey}", s.handleNodeDetail).Methods("GET")
 	r.HandleFunc("/api/nodes", s.handleNodes).Methods("GET")
 
@@ -139,18 +154,37 @@ func (s *Server) RegisterRoutes(r *mux.Router) {
 	r.HandleFunc("/api/analytics/hash-sizes", s.handleAnalyticsHashSizes).Methods("GET")
 	r.HandleFunc("/api/analytics/hash-collisions", s.handleAnalyticsHashCollisions).Methods("GET")
 	r.HandleFunc("/api/analytics/subpaths", s.handleAnalyticsSubpaths).Methods("GET")
+	r.HandleFunc("/api/analytics/subpaths-bulk", s.handleAnalyticsSubpathsBulk).Methods("GET")
 	r.HandleFunc("/api/analytics/subpath-detail", s.handleAnalyticsSubpathDetail).Methods("GET")
+	r.HandleFunc("/api/analytics/neighbor-graph", s.handleNeighborGraph).Methods("GET")
 
 	// Other endpoints
 	r.HandleFunc("/api/resolve-hops", s.handleResolveHops).Methods("GET")
 	r.HandleFunc("/api/channels/{hash}/messages", s.handleChannelMessages).Methods("GET")
 	r.HandleFunc("/api/channels", s.handleChannels).Methods("GET")
+	r.HandleFunc("/api/observers/metrics/summary", s.handleMetricsSummary).Methods("GET")
+	r.HandleFunc("/api/observers/{id}/metrics", s.handleObserverMetrics).Methods("GET")
 	r.HandleFunc("/api/observers/{id}/analytics", s.handleObserverAnalytics).Methods("GET")
 	r.HandleFunc("/api/observers/{id}", s.handleObserverDetail).Methods("GET")
 	r.HandleFunc("/api/observers", s.handleObservers).Methods("GET")
 	r.HandleFunc("/api/traces/{hash}", s.handleTraces).Methods("GET")
 	r.HandleFunc("/api/iata-coords", s.handleIATACoords).Methods("GET")
 	r.HandleFunc("/api/audio-lab/buckets", s.handleAudioLabBuckets).Methods("GET")
+
+	// OpenAPI spec + Swagger UI
+	r.HandleFunc("/api/spec", s.handleOpenAPISpec).Methods("GET")
+	r.HandleFunc("/api/docs", s.handleSwaggerUI).Methods("GET")
+}
+
+func (s *Server) backfillStatusMiddleware(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if s.store != nil && s.store.backfillComplete.Load() {
+			w.Header().Set("X-CoreScope-Status", "ready")
+		} else {
+			w.Header().Set("X-CoreScope-Status", "backfilling")
+		}
+		next.ServeHTTP(w, r)
+	})
 }
 
 func (s *Server) perfMiddleware(next http.Handler) http.Handler {
@@ -213,10 +247,15 @@ func (s *Server) requireAPIKey(next http.Handler) http.Handler {
 			writeError(w, http.StatusForbidden, "write endpoints disabled — set apiKey in config.json")
 			return
 		}
-		if r.Header.Get("X-API-Key") != s.cfg.APIKey {
+		key := r.Header.Get("X-API-Key")
+		if !constantTimeEqual(key, s.cfg.APIKey) {
 			writeError(w, http.StatusUnauthorized, "unauthorized")
 			return
 		}
+		if IsWeakAPIKey(key) {
+			writeError(w, http.StatusForbidden, "forbidden")
+			return
+		}
 		next.ServeHTTP(w, r)
 	})
 }
@@ -246,6 +285,7 @@ func (s *Server) handleConfigClient(w http.ResponseWriter, r *http.Request) {
 		ExternalUrls:        s.cfg.ExternalUrls,
 		PropagationBufferMs: float64(s.cfg.PropagationBufferMs()),
 		Timestamps:          s.cfg.GetTimestampConfig(),
+		DebugAffinity:       s.cfg.DebugAffinity,
 	})
 }
 
@@ -276,6 +316,26 @@ func (s *Server) handleConfigTheme(w http.ResponseWriter, r *http.Request) {
 		"accentHover": "#6db3ff",
 		"navBg":       "#0f0f23",
 		"navBg2":      "#1a1a2e",
+		"navText":     "#ffffff",
+		"navTextMuted": "#cbd5e1",
+		"background":  "#f4f5f7",
+		"text":        "#1a1a2e",
+		"textMuted":   "#5b6370",
+		"border":      "#e2e5ea",
+		"surface1":    "#ffffff",
+		"surface2":    "#ffffff",
+		"surface3":    "#ffffff",
+		"sectionBg":   "#eef2ff",
+		"cardBg":      "#ffffff",
+		"contentBg":   "#f4f5f7",
+		"detailBg":    "#ffffff",
+		"inputBg":     "#ffffff",
+		"rowStripe":   "#f9fafb",
+		"rowHover":    "#eef2ff",
+		"selectedBg":  "#dbeafe",
+		"statusGreen": "#22c55e",
+		"statusYellow": "#eab308",
+		"statusRed":   "#ef4444",
 	}, s.cfg.Theme, theme.Theme)
 
 	nodeColors := mergeMap(map[string]interface{}{
@@ -286,15 +346,60 @@ func (s *Server) handleConfigTheme(w http.ResponseWriter, r *http.Request) {
 		"observer":  "#8b5cf6",
 	}, s.cfg.NodeColors, theme.NodeColors)
 
-	themeDark := mergeMap(map[string]interface{}{}, s.cfg.ThemeDark, theme.ThemeDark)
-	typeColors := mergeMap(map[string]interface{}{}, s.cfg.TypeColors, theme.TypeColors)
+	themeDark := mergeMap(map[string]interface{}{
+		"accent":      "#4a9eff",
+		"accentHover": "#6db3ff",
+		"navBg":       "#0f0f23",
+		"navBg2":      "#1a1a2e",
+		"navText":     "#ffffff",
+		"navTextMuted": "#cbd5e1",
+		"background":  "#0f0f23",
+		"text":        "#e2e8f0",
+		"textMuted":   "#a8b8cc",
+		"border":      "#334155",
+		"surface1":    "#1a1a2e",
+		"surface2":    "#232340",
+		"cardBg":      "#1a1a2e",
+		"contentBg":   "#0f0f23",
+		"detailBg":    "#232340",
+		"inputBg":     "#1e1e34",
+		"rowStripe":   "#1e1e34",
+		"rowHover":    "#2d2d50",
+		"selectedBg":  "#1e3a5f",
+		"statusGreen": "#22c55e",
+		"statusYellow": "#eab308",
+		"statusRed":   "#ef4444",
+		"surface3":    "#2d2d50",
+		"sectionBg":   "#1e1e34",
+	}, s.cfg.ThemeDark, theme.ThemeDark)
+	typeColors := mergeMap(map[string]interface{}{
+		"ADVERT":   "#22c55e",
+		"GRP_TXT":  "#3b82f6",
+		"TXT_MSG":  "#f59e0b",
+		"ACK":      "#6b7280",
+		"REQUEST":  "#a855f7",
+		"RESPONSE": "#06b6d4",
+		"TRACE":    "#ec4899",
+		"PATH":     "#14b8a6",
+		"ANON_REQ": "#f43f5e",
+		"UNKNOWN":  "#6b7280",
+	}, s.cfg.TypeColors, theme.TypeColors)
 
-	var home interface{}
-	if theme.Home != nil {
-		home = theme.Home
-	} else if s.cfg.Home != nil {
-		home = s.cfg.Home
+	defaultHome := map[string]interface{}{
+		"heroTitle":    "CoreScope",
+		"heroSubtitle": "Real-time MeshCore LoRa mesh network analyzer",
+		"steps": []interface{}{
+			map[string]interface{}{"emoji": "🔵", "title": "Connect via Bluetooth", "description": "Flash **BLE companion** firmware from [MeshCore Flasher](https://flasher.meshcore.co.uk/).\n- Screenless devices: default PIN `123456`\n- Screen devices: random PIN shown on display\n- If pairing fails: forget device, reboot, re-pair"},
+			map[string]interface{}{"emoji": "📻", "title": "Set the right frequency preset", "description": "**US Recommended:**\n`910.525 MHz · BW 62.5 kHz · SF 7 · CR 5`\nSelect **\"US Recommended\"** in the app or flasher."},
+			map[string]interface{}{"emoji": "📡", "title": "Advertise yourself", "description": "Tap the signal icon → **Flood** to broadcast your node to the mesh. Companions only advert when you trigger it manually."},
+			map[string]interface{}{"emoji": "🔁", "title": "Check \"Heard N repeats\"", "description": "- **\"Sent\"** = transmitted, no confirmation\n- **\"Heard 0 repeats\"** = no repeater picked it up\n- **\"Heard 1+ repeats\"** = you're on the mesh!"},
+		},
+		"footerLinks": []interface{}{
+			map[string]interface{}{"label": "📦 Packets", "url": "#/packets"},
+			map[string]interface{}{"label": "🗺️ Network Map", "url": "#/map"},
+		},
 	}
+	home := mergeMap(defaultHome, s.cfg.Home, theme.Home)
 
 	writeJSON(w, ThemeResponse{
 		Branding:   branding,
@@ -444,6 +549,19 @@ func (s *Server) handleStats(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 	counts := s.db.GetRoleCounts()
+
+	// Compute backfill progress
+	backfilling := s.store != nil && !s.store.backfillComplete.Load()
+	var backfillProgress float64
+	if backfilling && s.store != nil && s.store.backfillTotal.Load() > 0 {
+		backfillProgress = float64(s.store.backfillProcessed.Load()) / float64(s.store.backfillTotal.Load())
+		if backfillProgress > 1 {
+			backfillProgress = 1
+		}
+	} else if !backfilling {
+		backfillProgress = 1
+	}
+
 	resp := &StatsResponse{
 		TotalPackets:       stats.TotalPackets,
 		TotalTransmissions: &stats.TotalTransmissions,
@@ -463,6 +581,8 @@ func (s *Server) handleStats(w http.ResponseWriter, r *http.Request) {
 			Companions: counts["companions"],
 			Sensors:    counts["sensors"],
 		},
+		Backfilling:      backfilling,
+		BackfillProgress: backfillProgress,
 	}
 
 	s.statsMu.Lock()
@@ -645,7 +765,8 @@ func (s *Server) handlePackets(w http.ResponseWriter, r *http.Request) {
 		Until:    r.URL.Query().Get("until"),
 		Region:   r.URL.Query().Get("region"),
 		Node:     r.URL.Query().Get("node"),
-		Order:    "DESC",
+		Order:              "DESC",
+		ExpandObservations: r.URL.Query().Get("expand") == "observations",
 	}
 	if r.URL.Query().Get("order") == "asc" {
 		q.Order = "ASC"
@@ -687,13 +808,6 @@ func (s *Server) handlePackets(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	// Strip observations from default response
-	if r.URL.Query().Get("expand") != "observations" {
-		for _, p := range result.Packets {
-			delete(p, "observations")
-		}
-	}
-
 	writeJSON(w, result)
 }
 
@@ -718,6 +832,38 @@ var muxBraceParam = regexp.MustCompile(`\{([^}]+)\}`)
 // perfHexFallback matches hex IDs for perf path normalization fallback.
 var perfHexFallback = regexp.MustCompile(`[0-9a-f]{8,}`)
 
+// handleBatchObservations returns observations for multiple hashes in a single request.
+// POST /api/packets/observations with JSON body: {"hashes": ["abc123", "def456", ...]}
+// Response: {"results": {"abc123": [...observations...], "def456": [...], ...}}
+// Limited to 200 hashes per request to prevent abuse.
+func (s *Server) handleBatchObservations(w http.ResponseWriter, r *http.Request) {
+	var body struct {
+		Hashes []string `json:"hashes"`
+	}
+	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
+		writeError(w, 400, "invalid JSON body")
+		return
+	}
+	const maxHashes = 200
+	if len(body.Hashes) > maxHashes {
+		writeError(w, 400, fmt.Sprintf("too many hashes (max %d)", maxHashes))
+		return
+	}
+	if len(body.Hashes) == 0 {
+		writeJSON(w, map[string]interface{}{"results": map[string]interface{}{}})
+		return
+	}
+
+	results := make(map[string][]ObservationResp, len(body.Hashes))
+	if s.store != nil {
+		for _, hash := range body.Hashes {
+			obs := s.store.GetObservationsForHash(hash)
+			results[hash] = mapSliceToObservations(obs)
+		}
+	}
+	writeJSON(w, map[string]interface{}{"results": results})
+}
+
 func (s *Server) handlePacketDetail(w http.ResponseWriter, r *http.Request) {
 	param := mux.Vars(r)["id"]
 	var packet map[string]interface{}
@@ -761,10 +907,11 @@ func (s *Server) handlePacketDetail(w http.ResponseWriter, r *http.Request) {
 		pathHops = []interface{}{}
 	}
 
+	rawHex, _ := packet["raw_hex"].(string)
 	writeJSON(w, PacketDetailResponse{
 		Packet:           packet,
 		Path:             pathHops,
-		Breakdown:        struct{}{},
+		Breakdown:        BuildBreakdown(rawHex),
 		ObservationCount: observationCount,
 		Observations:     mapSliceToObservations(observations),
 	})
@@ -783,7 +930,7 @@ func (s *Server) handleDecode(w http.ResponseWriter, r *http.Request) {
 		writeError(w, 400, "hex is required")
 		return
 	}
-	decoded, err := DecodePacket(hexStr)
+	decoded, err := DecodePacket(hexStr, true)
 	if err != nil {
 		writeError(w, 400, err.Error())
 		return
@@ -815,7 +962,7 @@ func (s *Server) handlePostPacket(w http.ResponseWriter, r *http.Request) {
 		writeError(w, 400, "hex is required")
 		return
 	}
-	decoded, err := DecodePacket(hexStr)
+	decoded, err := DecodePacket(hexStr, false)
 	if err != nil {
 		writeError(w, 400, err.Error())
 		return
@@ -991,16 +1138,55 @@ func (s *Server) handleNodePaths(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	prefix1 := strings.ToLower(pubkey)
-	if len(prefix1) > 2 {
-		prefix1 = prefix1[:2]
-	}
-	prefix2 := strings.ToLower(pubkey)
+	// Use the precomputed byPathHop index instead of scanning all packets.
+	// Look up by full pubkey (resolved hops) and by short prefixes (raw hops).
+	lowerPK := strings.ToLower(pubkey)
+	prefix2 := lowerPK
 	if len(prefix2) > 4 {
 		prefix2 = prefix2[:4]
 	}
+	prefix1 := lowerPK
+	if len(prefix1) > 2 {
+		prefix1 = prefix1[:2]
+	}
+
 	s.store.mu.RLock()
 	_, pm := s.store.getCachedNodesAndPM()
+
+	// Collect candidate transmissions from the index, deduplicating by tx ID.
+	seen := make(map[int]bool)
+	var candidates []*StoreTx
+	addCandidates := func(key string) {
+		for _, tx := range s.store.byPathHop[key] {
+			if !seen[tx.ID] {
+				seen[tx.ID] = true
+				candidates = append(candidates, tx)
+			}
+		}
+	}
+	addCandidates(lowerPK) // full pubkey match (from resolved_path)
+	addCandidates(prefix1) // 2-char raw hop match
+	addCandidates(prefix2) // 4-char raw hop match
+	// Also check any raw hops that start with prefix2 (longer prefixes).
+	// Raw hops are typically 2 chars, so iterate only keys with HasPrefix
+	// on the small set of index keys rather than all packets.
+	for key := range s.store.byPathHop {
+		if len(key) > 4 && len(key) < len(lowerPK) && strings.HasPrefix(key, prefix2) {
+			addCandidates(key)
+		}
+	}
+
+	// Post-filter: verify target node actually appears in each candidate's resolved_path.
+	// The byPathHop index uses short prefixes which can collide (e.g. "c0" matches multiple nodes).
+	// We lean on resolved_path (from neighbor affinity graph) to disambiguate.
+	filtered := candidates[:0] // reuse backing array
+	for _, tx := range candidates {
+		if nodeInResolvedPath(tx, lowerPK) {
+			filtered = append(filtered, tx)
+		}
+	}
+	candidates = filtered
+
 	type pathAgg struct {
 		Hops       []PathHopResp
 		Count      int
@@ -1014,28 +1200,13 @@ func (s *Server) handleNodePaths(w http.ResponseWriter, r *http.Request) {
 		if cached, ok := hopCache[hop]; ok {
 			return cached
 		}
-		r := pm.resolve(hop)
+		r, _, _ := pm.resolveWithContext(hop, nil, s.store.graph)
 		hopCache[hop] = r
 		return r
 	}
-	for _, tx := range s.store.packets {
-		hops := txGetParsedPath(tx)
-		if len(hops) == 0 {
-			continue
-		}
-		found := false
-		for _, hop := range hops {
-			hl := strings.ToLower(hop)
-			if hl == prefix1 || hl == prefix2 || strings.HasPrefix(hl, prefix2) {
-				found = true
-				break
-			}
-		}
-		if !found {
-			continue
-		}
-
+	for _, tx := range candidates {
 		totalTransmissions++
+		hops := txGetParsedPath(tx)
 		resolvedHops := make([]PathHopResp, len(hops))
 		sigParts := make([]string, len(hops))
 		for i, hop := range hops {
@@ -1263,6 +1434,57 @@ func (s *Server) handleAnalyticsSubpaths(w http.ResponseWriter, r *http.Request)
 	})
 }
 
+// handleAnalyticsSubpathsBulk returns multiple length-range buckets in a single
+// response, avoiding repeated scans of the same packet data. Query format:
+//   ?groups=2-2:50,3-3:30,4-4:20,5-8:15   (minLen-maxLen:limit per group)
+func (s *Server) handleAnalyticsSubpathsBulk(w http.ResponseWriter, r *http.Request) {
+	region := r.URL.Query().Get("region")
+	groupsParam := r.URL.Query().Get("groups")
+	if groupsParam == "" {
+		writeJSON(w, ErrorResp{Error: "groups parameter required (e.g. groups=2-2:50,3-3:30)"})
+		return
+	}
+
+	var groups []subpathGroup
+	for _, g := range strings.Split(groupsParam, ",") {
+		parts := strings.SplitN(g, ":", 2)
+		if len(parts) != 2 {
+			writeJSON(w, ErrorResp{Error: "invalid group format: " + g})
+			return
+		}
+		rangeParts := strings.SplitN(parts[0], "-", 2)
+		if len(rangeParts) != 2 {
+			writeJSON(w, ErrorResp{Error: "invalid range format: " + parts[0]})
+			return
+		}
+		mn, err1 := strconv.Atoi(rangeParts[0])
+		mx, err2 := strconv.Atoi(rangeParts[1])
+		lim, err3 := strconv.Atoi(parts[1])
+		if err1 != nil || err2 != nil || err3 != nil || mn < 2 || mx < mn || lim < 1 {
+			writeJSON(w, ErrorResp{Error: "invalid group: " + g})
+			return
+		}
+		groups = append(groups, subpathGroup{mn, mx, lim})
+	}
+
+	if s.store == nil {
+		results := make([]map[string]interface{}, len(groups))
+		for i := range groups {
+			results[i] = map[string]interface{}{"subpaths": []interface{}{}, "totalPaths": 0}
+		}
+		writeJSON(w, map[string]interface{}{"results": results})
+		return
+	}
+
+	results := s.store.GetAnalyticsSubpathsBulk(region, groups)
+	writeJSON(w, map[string]interface{}{"results": results})
+}
+
+// subpathGroup defines a length-range + limit for the bulk subpaths endpoint.
+type subpathGroup struct {
+	MinLen, MaxLen, Limit int
+}
+
 func (s *Server) handleAnalyticsSubpathDetail(w http.ResponseWriter, r *http.Request) {
 	hops := r.URL.Query().Get("hops")
 	if hops == "" {
@@ -1302,43 +1524,128 @@ func (s *Server) handleResolveHops(w http.ResponseWriter, r *http.Request) {
 	hops := strings.Split(hopsParam, ",")
 	resolved := map[string]*HopResolution{}
 
+	// Context for affinity-based disambiguation.
+	fromNode := r.URL.Query().Get("from_node")
+	observer := r.URL.Query().Get("observer")
+	var contextPubkeys []string
+	if fromNode != "" {
+		contextPubkeys = append(contextPubkeys, fromNode)
+	}
+	if observer != "" {
+		contextPubkeys = append(contextPubkeys, observer)
+	}
+
+	// Get the neighbor graph for affinity scoring (may be nil).
+	var graph *NeighborGraph
+	if len(contextPubkeys) > 0 {
+		graph = s.getNeighborGraph()
+	}
+
+	// Get the server's prefix map for resolveWithContext.
+	var pm *prefixMap
+	if s.store != nil {
+		s.store.mu.RLock()
+		_, pm = s.store.getCachedNodesAndPM()
+		s.store.mu.RUnlock()
+	}
+
 	for _, hop := range hops {
 		if hop == "" {
 			continue
 		}
 		hopLower := strings.ToLower(hop)
-		rows, err := s.db.conn.Query("SELECT public_key, name, lat, lon FROM nodes WHERE LOWER(public_key) LIKE ?", hopLower+"%")
-		if err != nil {
-			resolved[hop] = &HopResolution{Name: nil, Candidates: []HopCandidate{}, Conflicts: []interface{}{}}
-			continue
-		}
 
+		// Resolve candidates from the in-memory prefix map instead of
+		// issuing per-hop DB queries (fixes N+1 pattern, see #369).
 		var candidates []HopCandidate
-		for rows.Next() {
-			var pk string
-			var name sql.NullString
-			var lat, lon sql.NullFloat64
-			rows.Scan(&pk, &name, &lat, &lon)
-			candidates = append(candidates, HopCandidate{
-				Name: nullStr(name), Pubkey: pk,
-				Lat: nullFloat(lat), Lon: nullFloat(lon),
-			})
+		if pm != nil {
+			if matched, ok := pm.m[hopLower]; ok {
+				for _, ni := range matched {
+					c := HopCandidate{Pubkey: ni.PublicKey}
+					if ni.Name != "" {
+						c.Name = ni.Name
+					}
+					if ni.HasGPS {
+						c.Lat = ni.Lat
+						c.Lon = ni.Lon
+					}
+					candidates = append(candidates, c)
+				}
+			}
 		}
-		rows.Close()
 
 		if len(candidates) == 0 {
-			resolved[hop] = &HopResolution{Name: nil, Candidates: []HopCandidate{}, Conflicts: []interface{}{}}
+			resolved[hop] = &HopResolution{Name: nil, Candidates: []HopCandidate{}, Conflicts: []interface{}{}, Confidence: "no_match"}
 		} else if len(candidates) == 1 {
 			resolved[hop] = &HopResolution{
 				Name: candidates[0].Name, Pubkey: candidates[0].Pubkey,
 				Candidates: candidates, Conflicts: []interface{}{},
+				Confidence: "unique_prefix",
 			}
 		} else {
+			// Compute affinity scores for each candidate if we have context.
+			if graph != nil && len(contextPubkeys) > 0 {
+				now := time.Now()
+				for i := range candidates {
+					candPK := strings.ToLower(candidates[i].Pubkey)
+					bestScore := 0.0
+					for _, ctxPK := range contextPubkeys {
+						edges := graph.Neighbors(strings.ToLower(ctxPK))
+						for _, e := range edges {
+							if e.Ambiguous {
+								continue
+							}
+							otherPK := e.NodeA
+							if strings.EqualFold(otherPK, ctxPK) {
+								otherPK = e.NodeB
+							}
+							if strings.EqualFold(otherPK, candPK) {
+								sc := e.Score(now)
+								if sc > bestScore {
+									bestScore = sc
+								}
+							}
+						}
+					}
+					if bestScore > 0 {
+						s := bestScore
+						candidates[i].AffinityScore = &s
+					}
+				}
+			}
+
+			// Use resolveWithContext for 4-tier disambiguation.
+			var best *nodeInfo
+			var confidence string
+			if pm != nil {
+				best, confidence, _ = pm.resolveWithContext(hopLower, contextPubkeys, graph)
+			}
+
 			ambig := true
-			resolved[hop] = &HopResolution{
+			hr := &HopResolution{
 				Name: candidates[0].Name, Pubkey: candidates[0].Pubkey,
 				Ambiguous: &ambig, Candidates: candidates, Conflicts: hopCandidatesToConflicts(candidates),
+				Confidence: "ambiguous",
 			}
+
+			// Use the resolved node as the default (best-effort pick).
+			if best != nil {
+				hr.Name = best.Name
+				hr.Pubkey = best.PublicKey
+			}
+
+			// Only promote to bestCandidate when affinity is confident.
+			if confidence == "neighbor_affinity" && best != nil {
+				pk := best.PublicKey
+				hr.BestCandidate = &pk
+				hr.Confidence = "neighbor_affinity"
+			} else if (confidence == "geo_proximity" || confidence == "gps_preference" || confidence == "first_match") && best != nil {
+				// Propagate lower-priority tiers so the API reflects the actual
+				// resolution strategy used, rather than collapsing everything to "ambiguous".
+				hr.Confidence = confidence
+			}
+
+			resolved[hop] = hr
 		}
 	}
 	writeJSON(w, ResolveHopsResponse{Resolved: resolved})
@@ -1388,8 +1695,12 @@ func (s *Server) handleObservers(w http.ResponseWriter, r *http.Request) {
 	oneHourAgo := time.Now().Add(-1 * time.Hour).Unix()
 	pktCounts := s.db.GetObserverPacketCounts(oneHourAgo)
 
-	// Batch lookup: node locations (observer ID may match a node public_key)
-	nodeLocations := s.db.GetNodeLocations()
+	// Batch lookup: node locations only for observer IDs (not all nodes)
+	observerIDs := make([]string, len(observers))
+	for i, o := range observers {
+		observerIDs[i] = o.ID
+	}
+	nodeLocations := s.db.GetNodeLocationsByKeys(observerIDs)
 
 	result := make([]ObserverResp, 0, len(observers))
 	for _, o := range observers {
@@ -1800,13 +2111,7 @@ func percentile(sorted []float64, p float64) float64 {
 func sortedCopy(arr []float64) []float64 {
 	cp := make([]float64, len(arr))
 	copy(cp, arr)
-	for i := 0; i < len(cp); i++ {
-		for j := i + 1; j < len(cp); j++ {
-			if cp[j] < cp[i] {
-				cp[i], cp[j] = cp[j], cp[i]
-			}
-		}
-	}
+	sort.Float64s(cp)
 	return cp
 }
 
@@ -1845,6 +2150,9 @@ func mapSliceToTransmissions(maps []map[string]interface{}) []TransmissionResp {
 		tx.PathJSON = m["path_json"]
 		tx.Direction = m["direction"]
 		tx.Score = m["score"]
+		if rp, ok := m["resolved_path"].([]*string); ok {
+			tx.ResolvedPath = rp
+		}
 		result = append(result, tx)
 	}
 	return result
@@ -1866,6 +2174,9 @@ func mapSliceToObservations(maps []map[string]interface{}) []ObservationResp {
 		obs.RSSI = m["rssi"]
 		obs.PathJSON = m["path_json"]
 		obs.Timestamp = m["timestamp"]
+		if rp, ok := m["resolved_path"].([]*string); ok {
+			obs.ResolvedPath = rp
+		}
 		result = append(result, obs)
 	}
 	return result
@@ -1898,6 +2209,112 @@ func nullFloatVal(n sql.NullFloat64) float64 {
 	return 0
 }
 
+func (s *Server) handleObserverMetrics(w http.ResponseWriter, r *http.Request) {
+	id := mux.Vars(r)["id"]
+	since := r.URL.Query().Get("since")
+	until := r.URL.Query().Get("until")
+	resolution := r.URL.Query().Get("resolution")
+
+	// Default to last 24h if no since provided
+	if since == "" {
+		since = time.Now().UTC().Add(-24 * time.Hour).Format(time.RFC3339)
+	}
+
+	// Validate resolution
+	if resolution == "" {
+		resolution = "5m"
+	}
+	switch resolution {
+	case "5m", "1h", "1d":
+		// valid
+	default:
+		writeError(w, 400, "invalid resolution: "+resolution+". Must be 5m, 1h, or 1d")
+		return
+	}
+
+	// Sample interval (default 300s = 5min)
+	sampleInterval := 300
+
+	metrics, reboots, err := s.db.GetObserverMetrics(id, since, until, resolution, sampleInterval)
+	if err != nil {
+		writeError(w, 500, err.Error())
+		return
+	}
+	if metrics == nil {
+		metrics = []MetricsSample{}
+	}
+	if reboots == nil {
+		reboots = []string{}
+	}
+
+	// Get observer name
+	obs, _ := s.db.GetObserverByID(id)
+	var name *string
+	if obs != nil {
+		name = obs.Name
+	}
+
+	writeJSON(w, map[string]interface{}{
+		"observer_id":   id,
+		"observer_name": name,
+		"reboots":       reboots,
+		"metrics":       metrics,
+	})
+}
+
+func (s *Server) handleMetricsSummary(w http.ResponseWriter, r *http.Request) {
+	window := r.URL.Query().Get("window")
+	if window == "" {
+		window = "24h"
+	}
+	region := r.URL.Query().Get("region")
+
+	// Parse window duration
+	dur, err := parseWindowDuration(window)
+	if err != nil {
+		writeError(w, 400, "invalid window: "+window)
+		return
+	}
+
+	since := time.Now().UTC().Add(-dur).Format(time.RFC3339)
+	summary, err := s.db.GetMetricsSummary(since)
+	if err != nil {
+		writeError(w, 500, err.Error())
+		return
+	}
+	if summary == nil {
+		summary = []MetricsSummaryRow{}
+	}
+
+	// Filter by region if specified
+	if region != "" {
+		filtered := make([]MetricsSummaryRow, 0)
+		for _, row := range summary {
+			if strings.EqualFold(row.IATA, region) {
+				filtered = append(filtered, row)
+			}
+		}
+		summary = filtered
+	}
+
+	writeJSON(w, map[string]interface{}{
+		"observers": summary,
+	})
+}
+
+// parseWindowDuration parses strings like "24h", "3d", "7d", "30d".
+func parseWindowDuration(window string) (time.Duration, error) {
+	if strings.HasSuffix(window, "d") {
+		daysStr := strings.TrimSuffix(window, "d")
+		days, err := strconv.Atoi(daysStr)
+		if err != nil || days <= 0 {
+			return 0, fmt.Errorf("invalid days: %s", daysStr)
+		}
+		return time.Duration(days) * 24 * time.Hour, nil
+	}
+	return time.ParseDuration(window)
+}
+
 func (s *Server) handleAdminPrune(w http.ResponseWriter, r *http.Request) {
 	days := 0
 	if d := r.URL.Query().Get("days"); d != "" {
@@ -1918,3 +2335,8 @@ func (s *Server) handleAdminPrune(w http.ResponseWriter, r *http.Request) {
 	log.Printf("[prune] deleted %d transmissions older than %d days", n, days)
 	writeJSON(w, map[string]interface{}{"deleted": n, "days": days})
 }
+
+// constantTimeEqual compares two strings in constant time to prevent timing attacks.
+func constantTimeEqual(a, b string) bool {
+	return subtle.ConstantTimeCompare([]byte(a), []byte(b)) == 1
+}

cmd/server/routes_test.go

@@ -6,6 +6,7 @@ import (
 	"net/http"
 	"net/http/httptest"
 	"strconv"
+	"strings"
 	"testing"
 	"time"
 
@@ -47,7 +48,7 @@ func setupTestServerWithAPIKey(t *testing.T, apiKey string) (*Server, *mux.Route
 }
 
 func TestWriteEndpointsRequireAPIKey(t *testing.T) {
-	_, router := setupTestServerWithAPIKey(t, "test-secret")
+	_, router := setupTestServerWithAPIKey(t, "test-secret-key-strong-enough")
 
 	t.Run("missing key returns 401", func(t *testing.T) {
 		req := httptest.NewRequest("POST", "/api/perf/reset", nil)
@@ -65,7 +66,7 @@ func TestWriteEndpointsRequireAPIKey(t *testing.T) {
 
 	t.Run("wrong key returns 401", func(t *testing.T) {
 		req := httptest.NewRequest("POST", "/api/perf/reset", nil)
-		req.Header.Set("X-API-Key", "wrong-secret")
+		req.Header.Set("X-API-Key", "wrong-secret-key-strong-enough")
 		w := httptest.NewRecorder()
 		router.ServeHTTP(w, req)
 		if w.Code != http.StatusUnauthorized {
@@ -75,7 +76,7 @@ func TestWriteEndpointsRequireAPIKey(t *testing.T) {
 
 	t.Run("correct key passes", func(t *testing.T) {
 		req := httptest.NewRequest("POST", "/api/perf/reset", nil)
-		req.Header.Set("X-API-Key", "test-secret")
+		req.Header.Set("X-API-Key", "test-secret-key-strong-enough")
 		w := httptest.NewRecorder()
 		router.ServeHTTP(w, req)
 		if w.Code != http.StatusOK {
@@ -1105,6 +1106,63 @@ func TestAnalyticsSubpaths(t *testing.T) {
 	}
 }
 
+func TestAnalyticsSubpathsBulk(t *testing.T) {
+	_, router := setupTestServer(t)
+
+	// Valid request with multiple groups.
+	req := httptest.NewRequest("GET", "/api/analytics/subpaths-bulk?groups=2-2:50,3-3:30,5-8:15", nil)
+	w := httptest.NewRecorder()
+	router.ServeHTTP(w, req)
+	if w.Code != 200 {
+		t.Fatalf("expected 200, got %d", w.Code)
+	}
+	var body map[string]interface{}
+	json.Unmarshal(w.Body.Bytes(), &body)
+	results, ok := body["results"].([]interface{})
+	if !ok {
+		t.Fatal("expected results array")
+	}
+	if len(results) != 3 {
+		t.Errorf("expected 3 result groups, got %d", len(results))
+	}
+	// Each result should have subpaths and totalPaths.
+	for i, r := range results {
+		rm, ok := r.(map[string]interface{})
+		if !ok {
+			t.Fatalf("result %d not a map", i)
+		}
+		if _, ok := rm["subpaths"]; !ok {
+			t.Errorf("result %d missing subpaths", i)
+		}
+		if _, ok := rm["totalPaths"]; !ok {
+			t.Errorf("result %d missing totalPaths", i)
+		}
+	}
+
+	// Missing groups param → error.
+	req2 := httptest.NewRequest("GET", "/api/analytics/subpaths-bulk", nil)
+	w2 := httptest.NewRecorder()
+	router.ServeHTTP(w2, req2)
+	if w2.Code != 200 {
+		t.Fatalf("expected 200 with error body, got %d", w2.Code)
+	}
+	var errBody map[string]interface{}
+	json.Unmarshal(w2.Body.Bytes(), &errBody)
+	if _, ok := errBody["error"]; !ok {
+		t.Error("expected error field for missing groups param")
+	}
+
+	// Invalid group format.
+	req3 := httptest.NewRequest("GET", "/api/analytics/subpaths-bulk?groups=bad", nil)
+	w3 := httptest.NewRecorder()
+	router.ServeHTTP(w3, req3)
+	var errBody3 map[string]interface{}
+	json.Unmarshal(w3.Body.Bytes(), &errBody3)
+	if _, ok := errBody3["error"]; !ok {
+		t.Error("expected error for invalid group format")
+	}
+}
+
 func TestAnalyticsSubpathDetailWithHops(t *testing.T) {
 	_, router := setupTestServer(t)
 	req := httptest.NewRequest("GET", "/api/analytics/subpath-detail?hops=aa,bb", nil)
@@ -1170,6 +1228,11 @@ func TestResolveHopsAmbiguous(t *testing.T) {
 	cfg := &Config{Port: 3000}
 	hub := NewHub()
 	srv := NewServer(db, cfg, hub)
+	store := NewPacketStore(db, nil)
+	if err := store.Load(); err != nil {
+		t.Fatalf("store.Load failed: %v", err)
+	}
+	srv.store = store
 	router := mux.NewRouter()
 	srv.RegisterRoutes(router)
 
@@ -1596,6 +1659,47 @@ func TestConfigThemeWithCustomConfig(t *testing.T) {
 	}
 }
 
+func TestConfigThemeHomeDefaults(t *testing.T) {
+	// When no home config is set, server should return built-in defaults
+	db := setupTestDB(t)
+	seedTestData(t, db)
+	cfg := &Config{Port: 3000} // no Home set
+	hub := NewHub()
+	srv := NewServer(db, cfg, hub)
+	router := mux.NewRouter()
+	srv.RegisterRoutes(router)
+
+	req := httptest.NewRequest("GET", "/api/config/theme", nil)
+	w := httptest.NewRecorder()
+	router.ServeHTTP(w, req)
+
+	if w.Code != 200 {
+		t.Fatalf("expected 200, got %d", w.Code)
+	}
+	var body map[string]interface{}
+	if err := json.Unmarshal(w.Body.Bytes(), &body); err != nil {
+		t.Fatalf("failed to unmarshal: %v", err)
+	}
+	home, ok := body["home"].(map[string]interface{})
+	if !ok || home == nil {
+		t.Fatal("expected non-null home object in theme response")
+	}
+	if home["heroTitle"] != "CoreScope" {
+		t.Errorf("expected heroTitle=CoreScope, got %v", home["heroTitle"])
+	}
+	if home["heroSubtitle"] == nil {
+		t.Error("expected heroSubtitle in home defaults")
+	}
+	steps, ok := home["steps"].([]interface{})
+	if !ok || len(steps) == 0 {
+		t.Error("expected non-empty steps array in home defaults")
+	}
+	footerLinks, ok := home["footerLinks"].([]interface{})
+	if !ok || len(footerLinks) == 0 {
+		t.Error("expected non-empty footerLinks array in home defaults")
+	}
+}
+
 func TestConfigCacheWithCustomTTL(t *testing.T) {
 	db := setupTestDB(t)
 	seedTestData(t, db)
@@ -2064,7 +2168,7 @@ tx := &StoreTx{
 ID:          9000 + i,
 RawHex:      rawHex,
 Hash:        "testhash" + strconv.Itoa(i),
-FirstSeen:   "2024-01-01T00:00:00Z",
+FirstSeen:   time.Now().UTC().Format("2006-01-02T15:04:05.000Z"),
 PayloadType: &payloadType,
 DecodedJSON: decoded,
 }
@@ -2110,7 +2214,7 @@ for i, raw := range raws {
 		ID:          8000 + i,
 		RawHex:      raw,
 		Hash:        "dominant" + strconv.Itoa(i),
-		FirstSeen:   "2024-01-01T00:00:00Z",
+		FirstSeen:   time.Now().UTC().Format("2006-01-02T15:04:05.000Z"),
 		PayloadType: &payloadType,
 		DecodedJSON: decoded,
 	}
@@ -2149,12 +2253,13 @@ func TestGetNodeHashSizeInfoLatestWins(t *testing.T) {
 	// 4 historical 1-byte adverts, then 1 recent 2-byte advert (latest).
 	// Mode would pick 1 (majority), but latest-wins should pick 2.
 	raws := []string{raw1byte, raw1byte, raw1byte, raw1byte, raw2byte}
+	baseTime := time.Now().UTC().Add(-1 * time.Hour)
 	for i, raw := range raws {
 		tx := &StoreTx{
 			ID:          7000 + i,
 			RawHex:      raw,
 			Hash:        "latest" + strconv.Itoa(i),
-			FirstSeen:   "2024-01-01T0" + strconv.Itoa(i) + ":00:00Z",
+			FirstSeen:   baseTime.Add(time.Duration(i) * time.Minute).Format("2006-01-02T15:04:05.000Z"),
 			PayloadType: &payloadType,
 			DecodedJSON: decoded,
 		}
@@ -2178,6 +2283,125 @@ func TestGetNodeHashSizeInfoLatestWins(t *testing.T) {
 	}
 }
 
+func TestGetNodeHashSizeInfoIgnoreDirectZeroHop(t *testing.T) {
+	db := setupTestDB(t)
+	seedTestData(t, db)
+	store := NewPacketStore(db, nil)
+	if err := store.Load(); err != nil {
+		t.Fatalf("store.Load failed: %v", err)
+	}
+
+	pk := "dddd111122223333444455556666777788889999aaaabbbbccccddddeeee3333"
+	db.conn.Exec("INSERT OR IGNORE INTO nodes (public_key, name, role) VALUES (?, 'DirIgnore', 'repeater')", pk)
+
+	decoded := `{"name":"DirIgnore","pubKey":"` + pk + `"}`
+	rawFlood2B := "11" + "40" + "aabb" // FLOOD advert, hashSize=2
+	rawDirect0 := "12" + "00" + "aabb" // DIRECT advert, zero-hop (should be ignored)
+
+	payloadType := 4
+	raws := []string{rawFlood2B, rawDirect0, rawFlood2B, rawDirect0, rawFlood2B}
+	baseTime2 := time.Now().UTC().Add(-1 * time.Hour)
+	for i, raw := range raws {
+		tx := &StoreTx{
+			ID:          9150 + i,
+			RawHex:      raw,
+			Hash:        "dirignore" + strconv.Itoa(i),
+			FirstSeen:   baseTime2.Add(time.Duration(i) * time.Minute).Format("2006-01-02T15:04:05.000Z"),
+			PayloadType: &payloadType,
+			DecodedJSON: decoded,
+		}
+		store.packets = append(store.packets, tx)
+		store.byPayloadType[4] = append(store.byPayloadType[4], tx)
+	}
+
+	info := store.GetNodeHashSizeInfo()
+	ni := info[pk]
+	if ni == nil {
+		t.Fatal("expected hash info for test node")
+	}
+	if ni.HashSize != 2 {
+		t.Errorf("HashSize=%d, want 2 (direct zero-hop adverts should be ignored)", ni.HashSize)
+	}
+	if ni.Inconsistent {
+		t.Error("expected hash_size_inconsistent=false when direct zero-hop adverts are ignored")
+	}
+	if len(ni.AllSizes) != 1 || !ni.AllSizes[2] {
+		t.Errorf("expected only 2-byte size in AllSizes, got %#v", ni.AllSizes)
+	}
+}
+
+func TestGetNodeHashSizeInfoOnlyDirectZeroHopIgnored(t *testing.T) {
+	db := setupTestDB(t)
+	seedTestData(t, db)
+	store := NewPacketStore(db, nil)
+	if err := store.Load(); err != nil {
+		t.Fatalf("store.Load failed: %v", err)
+	}
+
+	pk := "eeee111122223333444455556666777788889999aaaabbbbccccddddeeee4444"
+	db.conn.Exec("INSERT OR IGNORE INTO nodes (public_key, name, role) VALUES (?, 'OnlyDirect', 'repeater')", pk)
+
+	decoded := `{"name":"OnlyDirect","pubKey":"` + pk + `"}`
+	rawDirect0 := "12" + "00" + "aabb"
+	payloadType := 4
+
+	tx := &StoreTx{
+		ID:          9160,
+		RawHex:      rawDirect0,
+		Hash:        "onlydirect0",
+		FirstSeen:   time.Now().UTC().Format("2006-01-02T15:04:05.000Z"),
+		PayloadType: &payloadType,
+		DecodedJSON: decoded,
+	}
+	store.packets = append(store.packets, tx)
+	store.byPayloadType[4] = append(store.byPayloadType[4], tx)
+
+	info := store.GetNodeHashSizeInfo()
+	if ni := info[pk]; ni != nil {
+		t.Errorf("expected nil hash info for direct zero-hop only node, got HashSize=%d", ni.HashSize)
+	}
+}
+
+func TestGetNodeHashSizeInfoDirectNonZeroHopCounted(t *testing.T) {
+	// A DIRECT advert with non-zero hop count should NOT be skipped —
+	// only zero-hop DIRECT adverts misreport hash size.
+	db := setupTestDB(t)
+	seedTestData(t, db)
+	store := NewPacketStore(db, nil)
+	if err := store.Load(); err != nil {
+		t.Fatalf("store.Load failed: %v", err)
+	}
+
+	pk := "ffff111122223333444455556666777788889999aaaabbbbccccddddeeee5555"
+	db.conn.Exec("INSERT OR IGNORE INTO nodes (public_key, name, role) VALUES (?, 'DirNonZero', 'repeater')", pk)
+
+	decoded := `{"name":"DirNonZero","pubKey":"` + pk + `"}`
+	// DIRECT advert (route type 2 = 0x02 in bits 0-1), path byte 0x41:
+	//   upper 2 bits = 01 → hash_size = 2, lower 6 bits = 0x01 → hop count 1 (non-zero)
+	rawDirectNonZero := "12" + "41" + "aabb" // header=0x12 (ADVERT|DIRECT), path=0x41
+	payloadType := 4
+
+	tx := &StoreTx{
+		ID:          9170,
+		RawHex:      rawDirectNonZero,
+		Hash:        "dirnonzero0",
+		FirstSeen:   time.Now().UTC().Format("2006-01-02T15:04:05.000Z"),
+		PayloadType: &payloadType,
+		DecodedJSON: decoded,
+	}
+	store.packets = append(store.packets, tx)
+	store.byPayloadType[4] = append(store.byPayloadType[4], tx)
+
+	info := store.GetNodeHashSizeInfo()
+	ni := info[pk]
+	if ni == nil {
+		t.Fatal("expected hash info for DIRECT non-zero-hop node — it should NOT be skipped")
+	}
+	if ni.HashSize != 2 {
+		t.Errorf("HashSize=%d, want 2 (DIRECT with hop count > 0 should be counted)", ni.HashSize)
+	}
+}
+
 func TestGetNodeHashSizeInfoNoAdverts(t *testing.T) {
 	// A node with no ADVERT packets should not appear in hash size info.
 	db := setupTestDB(t)
@@ -2196,7 +2420,7 @@ func TestGetNodeHashSizeInfoNoAdverts(t *testing.T) {
 		ID:          6000,
 		RawHex:      "0440aabb",
 		Hash:        "noadverts0",
-		FirstSeen:   "2024-01-01T00:00:00Z",
+		FirstSeen:   time.Now().UTC().Format("2006-01-02T15:04:05.000Z"),
 		PayloadType: &payloadType,
 		DecodedJSON: `{"pubKey":"` + pk + `"}`,
 	}
@@ -2228,6 +2452,7 @@ func TestHashAnalyticsZeroHopAdvert(t *testing.T) {
 
 	pk := "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"
 	db.conn.Exec("INSERT OR IGNORE INTO nodes (public_key, name, role) VALUES (?, 'ZeroHop', 'repeater')", pk)
+	store.InvalidateNodeCache()
 
 	decoded := `{"name":"ZeroHop","pubKey":"` + pk + `"}`
 	// header 0x05 → routeType=1 (FLOOD), pathByte=0x00 → hashSize=1
@@ -2238,7 +2463,7 @@ func TestHashAnalyticsZeroHopAdvert(t *testing.T) {
 		ID:          8000,
 		RawHex:      raw,
 		Hash:        "zerohop0",
-		FirstSeen:   "2024-01-01T00:00:00Z",
+		FirstSeen:   time.Now().UTC().Format("2006-01-02T15:04:05.000Z"),
 		PayloadType: &payloadType,
 		DecodedJSON: decoded,
 		// No PathJSON → txGetParsedPath returns nil (zero hops)
@@ -2281,6 +2506,11 @@ func TestAnalyticsHashSizeSameNameDifferentPubkey(t *testing.T) {
 	pk1 := "aaaa111122223333444455556666777788889999aaaabbbbccccddddeeee1111"
 	pk2 := "aaaa111122223333444455556666777788889999aaaabbbbccccddddeeee2222"
 
+	// Insert both nodes as repeaters so they appear in distributionByRepeaters.
+	db.conn.Exec("INSERT OR IGNORE INTO nodes (public_key, name, role) VALUES (?, 'SameName', 'repeater')", pk1)
+	db.conn.Exec("INSERT OR IGNORE INTO nodes (public_key, name, role) VALUES (?, 'SameName', 'repeater')", pk2)
+	store.InvalidateNodeCache()
+
 	decoded1 := `{"name":"SameName","pubKey":"` + pk1 + `"}`
 	decoded2 := `{"name":"SameName","pubKey":"` + pk2 + `"}`
 
@@ -2292,7 +2522,7 @@ func TestAnalyticsHashSizeSameNameDifferentPubkey(t *testing.T) {
 			ID:          6100 + i,
 			RawHex:      raw2byte,
 			Hash:        "samename" + strconv.Itoa(i),
-			FirstSeen:   "2024-01-01T00:00:00Z",
+			FirstSeen:   time.Now().UTC().Format("2006-01-02T15:04:05.000Z"),
 			PayloadType: &payloadType,
 			DecodedJSON: decoded,
 			PathJSON:    `["AABB"]`,
@@ -2332,6 +2562,158 @@ t.Errorf("field %q is null, expected []", field)
 }
 	}
 }
+func TestInconsistentNodesExcludesCompanions(t *testing.T) {
+	// Issue #566: inconsistentNodes should only include repeaters and room servers.
+	db := setupTestDB(t)
+	seedTestData(t, db)
+	store := NewPacketStore(db, nil)
+	if err := store.Load(); err != nil {
+		t.Fatalf("store.Load failed: %v", err)
+	}
+
+	now := time.Now().UTC().Format("2006-01-02T15:04:05.000Z")
+	payloadType := 4
+
+	// Create three nodes: repeater, room_server, companion — all with inconsistent hash sizes
+	nodes := []struct {
+		pk   string
+		role string
+	}{
+		{"aa11111111111111111111111111111111111111111111111111111111111111", "repeater"},
+		{"bb22222222222222222222222222222222222222222222222222222222222222", "room_server"},
+		{"cc33333333333333333333333333333333333333333333333333333333333333", "companion"},
+	}
+
+	for ni, n := range nodes {
+		db.conn.Exec("INSERT OR IGNORE INTO nodes (public_key, name, role) VALUES (?, ?, ?)", n.pk, "Node-"+n.role, n.role)
+		decoded := `{"name":"Node-` + n.role + `","pubKey":"` + n.pk + `"}`
+		// Create flip-flop pattern: 1-byte, 2-byte, 1-byte (transitions=2 → inconsistent)
+		// Use header 0x11 (routeType=FLOOD, payloadType=4) and pathByte 0x41/0x81
+		// (non-zero hop count) so packets aren't skipped by direct zero-hop filter.
+		raws := []string{"11" + "41" + "aabb", "11" + "81" + "aabb", "11" + "41" + "aabb"}
+		for i, raw := range raws {
+			tx := &StoreTx{
+				ID:          7000 + ni*10 + i,
+				RawHex:      raw,
+				Hash:        "incon-" + n.role + strconv.Itoa(i),
+				FirstSeen:   now,
+				PayloadType: &payloadType,
+				DecodedJSON: decoded,
+			}
+			store.packets = append(store.packets, tx)
+			store.byPayloadType[4] = append(store.byPayloadType[4], tx)
+		}
+	}
+
+	cfg := &Config{Port: 3000}
+	hub := NewHub()
+	srv := NewServer(db, cfg, hub)
+	srv.store = store
+	router := mux.NewRouter()
+	srv.RegisterRoutes(router)
+
+	req := httptest.NewRequest("GET", "/api/analytics/hash-collisions", nil)
+	w := httptest.NewRecorder()
+	router.ServeHTTP(w, req)
+
+	if w.Code != 200 {
+		t.Fatalf("expected 200, got %d", w.Code)
+	}
+	var body map[string]interface{}
+	json.Unmarshal(w.Body.Bytes(), &body)
+
+	incon := body["inconsistent_nodes"].([]interface{})
+	for _, item := range incon {
+		node := item.(map[string]interface{})
+		role := node["role"].(string)
+		if role == "companion" {
+			t.Error("companion node should be excluded from inconsistent_nodes")
+		}
+	}
+
+	// Repeater and room_server should be present
+	roles := make(map[string]bool)
+	for _, item := range incon {
+		node := item.(map[string]interface{})
+		roles[node["role"].(string)] = true
+	}
+	if !roles["repeater"] {
+		t.Error("expected repeater in inconsistent_nodes")
+	}
+	if !roles["room_server"] {
+		t.Error("expected room_server in inconsistent_nodes")
+	}
+}
+
+func TestHashSizeInfoTimeWindow(t *testing.T) {
+	// Issue #566: adverts older than 7 days should be excluded from hash size computation.
+	db := setupTestDB(t)
+	seedTestData(t, db)
+	store := NewPacketStore(db, nil)
+	if err := store.Load(); err != nil {
+		t.Fatalf("store.Load failed: %v", err)
+	}
+
+	pk := "dd44444444444444444444444444444444444444444444444444444444444444"
+	db.conn.Exec("INSERT OR IGNORE INTO nodes (public_key, name, role) VALUES (?, 'OldNode', 'repeater')", pk)
+
+	decoded := `{"name":"OldNode","pubKey":"` + pk + `"}`
+	payloadType := 4
+
+	// Old adverts (>7 days ago) with flip-flop pattern
+	// Use header 0x11 (routeType=FLOOD) and pathByte 0x41/0x81 (non-zero hop count)
+	// so packets aren't skipped by direct zero-hop filter.
+	oldTime := time.Now().UTC().Add(-10 * 24 * time.Hour).Format("2006-01-02T15:04:05.000Z")
+	oldRaws := []string{"11" + "41" + "aabb", "11" + "81" + "aabb", "11" + "41" + "aabb"}
+	for i, raw := range oldRaws {
+		tx := &StoreTx{
+			ID:          6000 + i,
+			RawHex:      raw,
+			Hash:        "old-" + strconv.Itoa(i),
+			FirstSeen:   oldTime,
+			PayloadType: &payloadType,
+			DecodedJSON: decoded,
+		}
+		store.packets = append(store.packets, tx)
+		store.byPayloadType[4] = append(store.byPayloadType[4], tx)
+	}
+
+	info := store.GetNodeHashSizeInfo()
+	ni := info[pk]
+	if ni != nil && ni.Inconsistent {
+		t.Error("old adverts (>7 days) should be excluded; node should not be flagged as inconsistent")
+	}
+
+	// Now add recent adverts with consistent hash size — should appear in info
+	pk2 := "ee55555555555555555555555555555555555555555555555555555555555555"
+	db.conn.Exec("INSERT OR IGNORE INTO nodes (public_key, name, role) VALUES (?, 'NewNode', 'repeater')", pk2)
+	decoded2 := `{"name":"NewNode","pubKey":"` + pk2 + `"}`
+	recentTime := time.Now().UTC().Format("2006-01-02T15:04:05.000Z")
+	for i := 0; i < 3; i++ {
+		tx := &StoreTx{
+			ID:          6100 + i,
+			RawHex:      "11" + "41" + "aabb",
+			Hash:        "new-" + strconv.Itoa(i),
+			FirstSeen:   recentTime,
+			PayloadType: &payloadType,
+			DecodedJSON: decoded2,
+		}
+		store.packets = append(store.packets, tx)
+		store.byPayloadType[4] = append(store.byPayloadType[4], tx)
+	}
+
+	// Invalidate cache before second call
+	store.hashSizeInfoMu.Lock()
+	store.hashSizeInfoCache = nil
+	store.hashSizeInfoMu.Unlock()
+
+	info2 := store.GetNodeHashSizeInfo()
+	ni2 := info2[pk2]
+	if ni2 == nil {
+		t.Error("recent adverts should be included in hash size info")
+	}
+}
+
 func TestObserverAnalyticsNoStore(t *testing.T) {
 	_, router := setupNoStoreServer(t)
 	req := httptest.NewRequest("GET", "/api/observers/obs1/analytics", nil)
@@ -2811,7 +3193,7 @@ func TestHashCollisionsClassification(t *testing.T) {
 }
 
 func TestHashCollisionsCacheTTL(t *testing.T) {
-	// Issue #420: collision cache should use dedicated TTL (60s), not rfCacheTTL (15s)
+	// Issue #420: collision cache should use dedicated TTL, default 3600s (1 hour)
 	db := setupTestDB(t)
 	seedTestData(t, db)
 	store := NewPacketStore(db, nil)
@@ -2819,8 +3201,8 @@ func TestHashCollisionsCacheTTL(t *testing.T) {
 		t.Fatalf("store.Load failed: %v", err)
 	}
 
-	if store.collisionCacheTTL != 60*time.Second {
-		t.Errorf("expected collisionCacheTTL=60s, got %v", store.collisionCacheTTL)
+	if store.collisionCacheTTL != 3600*time.Second {
+		t.Errorf("expected collisionCacheTTL=3600s, got %v", store.collisionCacheTTL)
 	}
 	if store.rfCacheTTL != 15*time.Second {
 		t.Errorf("expected rfCacheTTL=15s, got %v", store.rfCacheTTL)
@@ -2900,11 +3282,11 @@ func TestHashCollisionsWithCollision(t *testing.T) {
 	now := time.Now().UTC()
 	recent := now.Add(-1 * time.Hour).Format(time.RFC3339)
 
-	// Two nodes with same first byte 'CC', no adverts so hash_size=0 (included in all buckets)
+	// Two repeater nodes with same first byte 'CC' and hash_size=1
 	db.conn.Exec(`INSERT INTO nodes (public_key, name, role, lat, lon, last_seen, first_seen, advert_count)
-		VALUES ('CC11223344556677', 'Node1', 'repeater', 37.5, -122.0, ?, '2026-01-01T00:00:00Z', 0)`, recent)
+		VALUES ('CC11223344556677', 'Node1', 'repeater', 37.5, -122.0, ?, '2026-01-01T00:00:00Z', 5)`, recent)
 	db.conn.Exec(`INSERT INTO nodes (public_key, name, role, lat, lon, last_seen, first_seen, advert_count)
-		VALUES ('CC99887766554433', 'Node2', 'repeater', 37.51, -122.01, ?, '2026-01-01T00:00:00Z', 0)`, recent)
+		VALUES ('CC99887766554433', 'Node2', 'repeater', 37.51, -122.01, ?, '2026-01-01T00:00:00Z', 5)`, recent)
 
 	cfg := &Config{Port: 3000}
 	hub := NewHub()
@@ -2913,6 +3295,14 @@ func TestHashCollisionsWithCollision(t *testing.T) {
 	if err := store.Load(); err != nil {
 		t.Fatalf("store.Load failed: %v", err)
 	}
+	// Inject hash_size=1 for both nodes so they appear in the 1-byte bucket
+	store.hashSizeInfoMu.Lock()
+	store.hashSizeInfoCache = map[string]*hashSizeNodeInfo{
+		"CC11223344556677": {HashSize: 1, AllSizes: map[int]bool{1: true}},
+		"CC99887766554433": {HashSize: 1, AllSizes: map[int]bool{1: true}},
+	}
+	store.hashSizeInfoAt = time.Now()
+	store.hashSizeInfoMu.Unlock()
 	srv.store = store
 	router := mux.NewRouter()
 	srv.RegisterRoutes(router)
@@ -3027,3 +3417,330 @@ func TestHashCollisionsMissingCoordinates(t *testing.T) {
 		}
 	}
 }
+
+// TestHashCollisionsOnlyRepeaters verifies that only repeater nodes
+// are included in collision analysis. Companions, rooms, sensors, and
+// hash_size==0 nodes are excluded — per firmware analysis, only repeaters
+// forward packets and appear in path[] arrays. (#441)
+func TestHashCollisionsOnlyRepeaters(t *testing.T) {
+	db := setupTestDB(t)
+
+	// Insert nodes sharing the same 1-byte prefix "AA":
+	//   1. repeater with hash_size=1 → should be counted
+	//   2. repeater with hash_size=0 (unknown) → should be excluded
+	//   3. companion with hash_size=1 → should be excluded
+	//   4. room with hash_size=1 → should be excluded
+	//   5. sensor with hash_size=1 → should be excluded
+	now := time.Now().Format("2006-01-02 15:04:05")
+	db.conn.Exec(`INSERT INTO nodes (public_key, name, role, last_seen) VALUES
+		('aa11223344556677', 'Repeater1', 'repeater', ?),
+		('aa99887766554433', 'UnknownNode', 'repeater', ?),
+		('aadeadbeefcafe01', 'Companion1', 'companion', ?),
+		('aabbcc1122334455', 'Room1', 'room', ?),
+		('aabbcc9988776655', 'Sensor1', 'sensor', ?)`, now, now, now, now, now)
+
+	// We also need a second repeater with hash_size=1 and same prefix to
+	// confirm that genuine collisions ARE still detected.
+	db.conn.Exec(`INSERT INTO nodes (public_key, name, role, last_seen) VALUES
+		('aa00112233445566', 'Repeater2', 'repeater', ?)`, now)
+
+	cfg := &Config{Port: 3000}
+	hub := NewHub()
+	srv := NewServer(db, cfg, hub)
+	store := NewPacketStore(db, nil)
+	store.Load()
+	srv.store = store
+
+	// Inject hash size info directly into the cache
+	store.hashSizeInfoMu.Lock()
+	store.hashSizeInfoCache = map[string]*hashSizeNodeInfo{
+		"aa11223344556677": {HashSize: 1, AllSizes: map[int]bool{1: true}},
+		"aa00112233445566": {HashSize: 1, AllSizes: map[int]bool{1: true}},
+		"aa99887766554433": {HashSize: 0, AllSizes: map[int]bool{}},       // unknown
+		"aadeadbeefcafe01": {HashSize: 1, AllSizes: map[int]bool{1: true}}, // companion
+		"aabbcc1122334455": {HashSize: 1, AllSizes: map[int]bool{1: true}}, // room
+		"aabbcc9988776655": {HashSize: 1, AllSizes: map[int]bool{1: true}}, // sensor
+	}
+	store.hashSizeInfoAt = time.Now()
+	store.hashSizeInfoMu.Unlock()
+
+	result := store.computeHashCollisions("")
+
+	bySize, ok := result["by_size"].(map[string]interface{})
+	if !ok {
+		t.Fatal("missing by_size")
+	}
+
+	size1, ok := bySize["1"].(map[string]interface{})
+	if !ok {
+		t.Fatal("missing by_size[1]")
+	}
+
+	stats, ok := size1["stats"].(map[string]interface{})
+	if !ok {
+		t.Fatal("missing stats")
+	}
+
+	// Only Repeater1 and Repeater2 should be in nodesForByte (hash_size=1, role=repeater).
+	// UnknownNode (hash_size=0), Companion1, Room1, Sensor1 must all be excluded.
+	nodesForByte := stats["nodes_for_byte"]
+	if nodesForByte != 2 {
+		t.Errorf("expected nodes_for_byte=2 (only repeaters with hash_size=1), got %v", nodesForByte)
+	}
+
+	// They share prefix "AA", so there should be exactly 1 collision entry.
+	collisions, ok := size1["collisions"].([]collisionEntry)
+	if !ok {
+		t.Fatalf("collisions is not []collisionEntry")
+	}
+	if len(collisions) != 1 {
+		t.Errorf("expected 1 collision entry, got %d", len(collisions))
+	}
+	if len(collisions) == 1 && len(collisions[0].Nodes) != 2 {
+		t.Errorf("expected 2 nodes in collision, got %d", len(collisions[0].Nodes))
+	}
+}
+
+func TestNodePathsEndpointUsesIndex(t *testing.T) {
+	srv, router := setupTestServer(t)
+
+	// Verify byPathHop index was built during Load
+	srv.store.mu.RLock()
+	hopKeys := len(srv.store.byPathHop)
+	srv.store.mu.RUnlock()
+	if hopKeys == 0 {
+		t.Fatal("byPathHop index is empty after Load")
+	}
+
+	// Query paths for TestRepeater (pubkey aabbccdd11223344, prefix "aa")
+	// Should find transmissions with hop "aa" in path
+	req := httptest.NewRequest("GET", "/api/nodes/aabbccdd11223344/paths", nil)
+	w := httptest.NewRecorder()
+	router.ServeHTTP(w, req)
+
+	if w.Code != 200 {
+		t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
+	}
+
+	var resp struct {
+		Paths              []json.RawMessage `json:"paths"`
+		TotalTransmissions int               `json:"totalTransmissions"`
+	}
+	if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
+		t.Fatalf("bad JSON: %v", err)
+	}
+
+	// Transmission 1 has path ["aa","bb"] which contains "aa" matching prefix of aabbccdd11223344
+	if resp.TotalTransmissions == 0 {
+		t.Error("expected at least 1 transmission matching node paths")
+	}
+	if len(resp.Paths) == 0 {
+		t.Error("expected at least 1 path group")
+	}
+}
+
+func TestNodePathsPrefixCollisionFilter(t *testing.T) {
+	// Two nodes share the "aa" prefix: TestRepeater (aabbccdd11223344) and a
+	// second node (aacafe0000000000). Packets whose resolved_path points to
+	// the second node must NOT appear when querying TestRepeater's paths.
+	srv, router := setupTestServer(t)
+
+	// Manually inject a transmission whose raw path contains "aa" but whose
+	// resolved_path points to the other node (aacafe0000000000).
+	now := time.Now().UTC()
+	recent := now.Add(-30 * time.Minute).Format(time.RFC3339)
+	recentEpoch := now.Add(-30 * time.Minute).Unix()
+
+	// Insert a second node with the same 2-char prefix
+	srv.db.conn.Exec(`INSERT OR IGNORE INTO nodes (public_key, name, role, last_seen, first_seen, advert_count)
+		VALUES ('aacafe0000000000', 'CollisionNode', 'repeater', ?, '2026-01-01T00:00:00Z', 5)`, recent)
+
+	// Insert a transmission with path hop "aa" that resolves to the OTHER node
+	srv.db.conn.Exec(`INSERT INTO transmissions (raw_hex, hash, first_seen, route_type, payload_type, decoded_json)
+		VALUES ('FF01', 'collision_test_hash', ?, 1, 4, '{}')`, recent)
+	// Get its ID
+	var collisionTxID int
+	srv.db.conn.QueryRow(`SELECT id FROM transmissions WHERE hash='collision_test_hash'`).Scan(&collisionTxID)
+
+	srv.db.conn.Exec(`INSERT INTO observations (transmission_id, observer_idx, snr, rssi, path_json, timestamp, resolved_path)
+		VALUES (?, 1, 10.0, -90, '["aa","bb"]', ?, '["aacafe0000000000","eeff00112233aabb"]')`,
+		collisionTxID, recentEpoch)
+
+	// Reload store to pick up new data
+	store := NewPacketStore(srv.db, nil)
+	if err := store.Load(); err != nil {
+		t.Fatalf("store.Load failed: %v", err)
+	}
+	srv.store = store
+
+	// Query paths for TestRepeater — should NOT include the collision packet
+	req := httptest.NewRequest("GET", "/api/nodes/aabbccdd11223344/paths", nil)
+	w := httptest.NewRecorder()
+	router.ServeHTTP(w, req)
+
+	if w.Code != 200 {
+		t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
+	}
+
+	var resp struct {
+		Paths              []json.RawMessage `json:"paths"`
+		TotalTransmissions int               `json:"totalTransmissions"`
+	}
+	if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
+		t.Fatalf("bad JSON: %v", err)
+	}
+
+	// The collision packet should be filtered out. Only transmission 1 (and 3
+	// if prefix matches) should remain — but transmission 3 has path "cc" and
+	// resolved_path pointing to TestRoom, so only tx 1 should match.
+	// Check that collision_test_hash is not in any path group.
+	bodyStr := w.Body.String()
+	if strings.Contains(bodyStr, "collision_test_hash") {
+		t.Error("collision packet should have been filtered out but appeared in response")
+	}
+
+	// Query paths for CollisionNode — should include the collision packet
+	req2 := httptest.NewRequest("GET", "/api/nodes/aacafe0000000000/paths", nil)
+	w2 := httptest.NewRecorder()
+	router.ServeHTTP(w2, req2)
+
+	if w2.Code != 200 {
+		t.Fatalf("expected 200 for CollisionNode, got %d: %s", w2.Code, w2.Body.String())
+	}
+
+	body2 := w2.Body.String()
+	if !strings.Contains(body2, "collision_test_hash") {
+		t.Error("collision packet should appear for CollisionNode but was missing")
+	}
+}
+
+func TestNodeInResolvedPath(t *testing.T) {
+	target := "aabbccdd11223344"
+
+	// Case 1: tx.ResolvedPath contains target
+	pk := "aabbccdd11223344"
+	tx1 := &StoreTx{ResolvedPath: []*string{&pk}}
+	if !nodeInResolvedPath(tx1, target) {
+		t.Error("should match when ResolvedPath contains target")
+	}
+
+	// Case 2: tx.ResolvedPath contains different node
+	other := "aacafe0000000000"
+	tx2 := &StoreTx{ResolvedPath: []*string{&other}}
+	if nodeInResolvedPath(tx2, target) {
+		t.Error("should not match when ResolvedPath contains different node")
+	}
+
+	// Case 3: nil ResolvedPath — should match (no data to disambiguate, keep it)
+	tx3 := &StoreTx{}
+	if !nodeInResolvedPath(tx3, target) {
+		t.Error("should match when ResolvedPath is nil (no data to disambiguate)")
+	}
+
+	// Case 4: ResolvedPath with nil elements only — has data but no match
+	tx4 := &StoreTx{ResolvedPath: []*string{nil, nil}}
+	if nodeInResolvedPath(tx4, target) {
+		t.Error("should not match when all ResolvedPath elements are nil")
+	}
+
+	// Case 5: target in observation but not in tx.ResolvedPath
+	tx5 := &StoreTx{
+		ResolvedPath: []*string{&other},
+		Observations: []*StoreObs{
+			{ResolvedPath: []*string{&pk}},
+		},
+	}
+	if !nodeInResolvedPath(tx5, target) {
+		t.Error("should match when observation's ResolvedPath contains target")
+	}
+}
+
+func TestPathHopIndexIncrementalUpdate(t *testing.T) {
+	// Test that addTxToPathHopIndex and removeTxFromPathHopIndex work correctly
+	idx := make(map[string][]*StoreTx)
+
+	pk1 := "fullpubkey1"
+	tx1 := &StoreTx{
+		ID:       1,
+		PathJSON: `["ab","cd"]`,
+		ResolvedPath: []*string{&pk1, nil},
+	}
+
+	addTxToPathHopIndex(idx, tx1)
+
+	// Should be indexed under "ab", "cd", and "fullpubkey1"
+	if len(idx["ab"]) != 1 {
+		t.Errorf("expected 1 entry for 'ab', got %d", len(idx["ab"]))
+	}
+	if len(idx["cd"]) != 1 {
+		t.Errorf("expected 1 entry for 'cd', got %d", len(idx["cd"]))
+	}
+	if len(idx["fullpubkey1"]) != 1 {
+		t.Errorf("expected 1 entry for resolved pubkey, got %d", len(idx["fullpubkey1"]))
+	}
+
+	// Add another tx with overlapping hop
+	tx2 := &StoreTx{
+		ID:       2,
+		PathJSON: `["ab","ef"]`,
+	}
+	addTxToPathHopIndex(idx, tx2)
+
+	if len(idx["ab"]) != 2 {
+		t.Errorf("expected 2 entries for 'ab', got %d", len(idx["ab"]))
+	}
+	if len(idx["ef"]) != 1 {
+		t.Errorf("expected 1 entry for 'ef', got %d", len(idx["ef"]))
+	}
+
+	// Remove tx1
+	removeTxFromPathHopIndex(idx, tx1)
+
+	if len(idx["ab"]) != 1 {
+		t.Errorf("expected 1 entry for 'ab' after removal, got %d", len(idx["ab"]))
+	}
+	if _, ok := idx["cd"]; ok {
+		t.Error("expected 'cd' key to be deleted after removal")
+	}
+	if _, ok := idx["fullpubkey1"]; ok {
+		t.Error("expected resolved pubkey key to be deleted after removal")
+	}
+}
+
+func TestMetricsAPIEndpoints(t *testing.T) {
+	srv, router := setupTestServer(t)
+
+	now := time.Now().UTC()
+	t1 := now.Add(-1 * time.Hour).Format(time.RFC3339)
+
+	srv.db.conn.Exec("INSERT INTO observer_metrics (observer_id, timestamp, noise_floor) VALUES (?, ?, ?)",
+		"obs1", t1, -112.0)
+
+	// Test /api/observers/obs1/metrics
+	req := httptest.NewRequest("GET", "/api/observers/obs1/metrics", nil)
+	w := httptest.NewRecorder()
+	router.ServeHTTP(w, req)
+	if w.Code != 200 {
+		t.Fatalf("GET /api/observers/obs1/metrics = %d, want 200", w.Code)
+	}
+	var resp map[string]interface{}
+	json.Unmarshal(w.Body.Bytes(), &resp)
+	metrics, ok := resp["metrics"].([]interface{})
+	if !ok || len(metrics) != 1 {
+		t.Errorf("expected 1 metric in response, got %v", resp["metrics"])
+	}
+
+	// Test /api/observers/metrics/summary
+	req2 := httptest.NewRequest("GET", "/api/observers/metrics/summary?window=24h", nil)
+	w2 := httptest.NewRecorder()
+	router.ServeHTTP(w2, req2)
+	if w2.Code != 200 {
+		t.Fatalf("GET /api/observers/metrics/summary = %d, want 200", w2.Code)
+	}
+	var resp2 map[string]interface{}
+	json.Unmarshal(w2.Body.Bytes(), &resp2)
+	observers, ok := resp2["observers"].([]interface{})
+	if !ok || len(observers) != 1 {
+		t.Errorf("expected 1 observer in summary, got %v", resp2["observers"])
+	}
+}

cmd/server/types.go

@@ -68,6 +68,8 @@ type StatsResponse struct {
 	Commit             string     `json:"commit"`
 	BuildTime          string     `json:"buildTime"`
 	Counts             RoleCounts `json:"counts"`
+	Backfilling        bool       `json:"backfilling"`
+	BackfillProgress   float64    `json:"backfillProgress"`
 }
 
 // ─── Health ────────────────────────────────────────────────────────────────────
@@ -240,6 +242,7 @@ type TransmissionResp struct {
 	SNR              interface{}      `json:"snr"`
 	RSSI             interface{}      `json:"rssi"`
 	PathJSON         interface{}      `json:"path_json"`
+	ResolvedPath     []*string        `json:"resolved_path,omitempty"`
 	Direction        interface{}      `json:"direction"`
 	Score            interface{}      `json:"score,omitempty"`
 	Observations     []ObservationResp `json:"observations,omitempty"`
@@ -254,6 +257,7 @@ type ObservationResp struct {
 	SNR            interface{} `json:"snr"`
 	RSSI           interface{} `json:"rssi"`
 	PathJSON       interface{} `json:"path_json"`
+	ResolvedPath   []*string   `json:"resolved_path,omitempty"`
 	Timestamp      interface{} `json:"timestamp"`
 }
 
@@ -289,7 +293,7 @@ type PacketTimestampsResponse struct {
 type PacketDetailResponse struct {
 	Packet           interface{}       `json:"packet"`
 	Path             []interface{}     `json:"path"`
-	Breakdown        interface{}       `json:"breakdown"`
+	Breakdown        *Breakdown        `json:"breakdown"`
 	ObservationCount int               `json:"observation_count"`
 	Observations     []ObservationResp `json:"observations,omitempty"`
 }
@@ -873,18 +877,21 @@ type TraceResponse struct {
 // ─── Resolve Hops ──────────────────────────────────────────────────────────────
 
 type HopCandidate struct {
-	Name   interface{} `json:"name"`
-	Pubkey string      `json:"pubkey"`
-	Lat    interface{} `json:"lat"`
-	Lon    interface{} `json:"lon"`
+	Name          interface{} `json:"name"`
+	Pubkey        string      `json:"pubkey"`
+	Lat           interface{} `json:"lat"`
+	Lon           interface{} `json:"lon"`
+	AffinityScore *float64    `json:"affinityScore"`
 }
 
 type HopResolution struct {
-	Name       interface{}    `json:"name"`
-	Pubkey     interface{}    `json:"pubkey,omitempty"`
-	Ambiguous  *bool          `json:"ambiguous,omitempty"`
-	Candidates []HopCandidate `json:"candidates"`
-	Conflicts  []interface{}  `json:"conflicts"`
+	Name          interface{}    `json:"name"`
+	Pubkey        interface{}    `json:"pubkey,omitempty"`
+	Ambiguous     *bool          `json:"ambiguous,omitempty"`
+	Candidates    []HopCandidate `json:"candidates"`
+	Conflicts     []interface{}  `json:"conflicts"`
+	BestCandidate *string        `json:"bestCandidate,omitempty"`
+	Confidence    string         `json:"confidence,omitempty"`
 }
 
 type ResolveHopsResponse struct {
@@ -921,6 +928,7 @@ type ClientConfigResponse struct {
 	ExternalUrls       interface{} `json:"externalUrls"`
 	PropagationBufferMs float64         `json:"propagationBufferMs"`
 	Timestamps          TimestampConfig `json:"timestamps"`
+	DebugAffinity       bool            `json:"debugAffinity,omitempty"`
 }
 
 // ─── IATA Coords ───────────────────────────────────────────────────────────────

config.example.json

@@ -8,13 +8,15 @@
   },
   "https": {
     "cert": "/path/to/cert.pem",
-    "key": "/path/to/key.pem"
+    "key": "/path/to/key.pem",
+    "_comment": "TLS cert/key paths for direct HTTPS. Most deployments use Caddy (included in Docker) for auto-TLS instead."
   },
   "branding": {
     "siteName": "CoreScope",
     "tagline": "Real-time MeshCore LoRa mesh network analyzer",
     "logoUrl": null,
-    "faviconUrl": null
+    "faviconUrl": null,
+    "_comment": "Customize site name, tagline, logo, and favicon. logoUrl/faviconUrl can be absolute URLs or relative paths."
   },
   "theme": {
     "accent": "#4a9eff",
@@ -23,38 +25,75 @@
     "navBg2": "#1a1a2e",
     "statusGreen": "#45644c",
     "statusYellow": "#b08b2d",
-    "statusRed": "#b54a4a"
+    "statusRed": "#b54a4a",
+    "_comment": "CSS color overrides. Use the in-app Theme Customizer for live preview, then export values here."
   },
   "nodeColors": {
     "repeater": "#dc2626",
     "companion": "#2563eb",
     "room": "#16a34a",
     "sensor": "#d97706",
-    "observer": "#8b5cf6"
+    "observer": "#8b5cf6",
+    "_comment": "Marker/badge colors per node role. Used on map, nodes list, and live feed."
   },
   "home": {
     "heroTitle": "CoreScope",
     "heroSubtitle": "Find your nodes to start monitoring them.",
     "steps": [
-      { "emoji": "📡", "title": "Connect", "description": "Link your node to the mesh" },
-      { "emoji": "🔍", "title": "Monitor", "description": "Watch packets flow in real-time" },
-      { "emoji": "📊", "title": "Analyze", "description": "Understand your network's health" }
+      {
+        "emoji": "\ud83d\udce1",
+        "title": "Connect",
+        "description": "Link your node to the mesh"
+      },
+      {
+        "emoji": "\ud83d\udd0d",
+        "title": "Monitor",
+        "description": "Watch packets flow in real-time"
+      },
+      {
+        "emoji": "\ud83d\udcca",
+        "title": "Analyze",
+        "description": "Understand your network's health"
+      }
     ],
     "checklist": [
-      { "question": "How do I add my node?", "answer": "Search for your node name or paste your public key." },
-      { "question": "What regions are covered?", "answer": "Check the map page to see active observers and nodes." }
+      {
+        "question": "How do I add my node?",
+        "answer": "Search for your node name or paste your public key."
+      },
+      {
+        "question": "What regions are covered?",
+        "answer": "Check the map page to see active observers and nodes."
+      }
     ],
     "footerLinks": [
-      { "label": "📦 Packets", "url": "#/packets" },
-      { "label": "🗺️ Network Map", "url": "#/map" },
-      { "label": "🔴 Live", "url": "#/live" },
-      { "label": "📡 All Nodes", "url": "#/nodes" },
-      { "label": "💬 Channels", "url": "#/channels" }
-    ]
+      {
+        "label": "\ud83d\udce6 Packets",
+        "url": "#/packets"
+      },
+      {
+        "label": "\ud83d\uddfa\ufe0f Network Map",
+        "url": "#/map"
+      },
+      {
+        "label": "\ud83d\udd34 Live",
+        "url": "#/live"
+      },
+      {
+        "label": "\ud83d\udce1 All Nodes",
+        "url": "#/nodes"
+      },
+      {
+        "label": "\ud83d\udcac Channels",
+        "url": "#/channels"
+      }
+    ],
+    "_comment": "Customize the landing page hero, onboarding steps, FAQ, and footer links."
   },
   "mqtt": {
     "broker": "mqtt://localhost:1883",
-    "topic": "meshcore/+/+/packets"
+    "topic": "meshcore/+/+/packets",
+    "_comment": "Legacy single-broker config. Prefer mqttSources[] for multiple brokers."
   },
   "mqttSources": [
     {
@@ -150,11 +189,26 @@
     "timezone": "local",
     "formatPreset": "iso",
     "customFormat": "",
-    "allowCustomFormat": false
+    "allowCustomFormat": false,
+    "_comment": "defaultMode: ago|local|iso. timezone: local|utc. formatPreset: iso|us|eu. customFormat: strftime-style (requires allowCustomFormat: true)."
   },
   "packetStore": {
     "maxMemoryMB": 1024,
     "estimatedPacketBytes": 450,
     "_comment": "In-memory packet store. maxMemoryMB caps RAM usage. All packets loaded on startup, served from RAM."
-  }
-}
+  },
+  "resolvedPath": {
+    "backfillHours": 24,
+    "_comment": "How far back (hours) the async backfill scans for observations with NULL resolved_path. Default: 24. Set higher to backfill older data, lower to speed up startup."
+  },
+  "neighborGraph": {
+    "maxAgeDays": 5,
+    "_comment": "Neighbor edges older than this many days are pruned on startup and daily. Default: 5."
+  },
+  "_comment_mqttSources": "Each source connects to an MQTT broker. topics: what to subscribe to. iataFilter: only ingest packets from these regions (optional).",
+  "_comment_channelKeys": "Hex keys for decrypting channel messages. Key name = channel display name. public channel key is well-known.",
+  "_comment_hashChannels": "Channel names whose keys are derived via SHA256. Key = SHA256(name)[:16]. Listed here so the ingestor can auto-derive keys.",
+  "_comment_defaultRegion": "IATA code shown by default in region filters.",
+  "_comment_mapDefaults": "Initial map center [lat, lon] and zoom level.",
+  "_comment_regions": "IATA code to display name mapping. Packets are tagged with region codes by MQTT topic structure."
+}

docker-compose.example.yml

@@ -0,0 +1,20 @@
+# CoreScope — simple deployment using pre-built image from GHCR
+# Usage: docker compose -f docker-compose.example.yml up -d
+# Docs:  https://github.com/Kpa-clawbot/CoreScope/blob/master/DEPLOY.md
+
+services:
+  corescope:
+    image: ghcr.io/kpa-clawbot/corescope:latest
+    ports:
+      - "${HTTP_PORT:-80}:80"
+    volumes:
+      - ${DATA_DIR:-./data}:/app/data
+    environment:
+      - DISABLE_CADDY=${DISABLE_CADDY:-true}
+      - DISABLE_MOSQUITTO=${DISABLE_MOSQUITTO:-false}
+    restart: unless-stopped
+    healthcheck:
+      test: ["CMD", "wget", "-qO-", "http://localhost:3000/api/stats"]
+      interval: 30s
+      timeout: 5s
+      retries: 3

docker-compose.staging.yml

@@ -15,15 +15,11 @@ services:
     restart: unless-stopped
     stop_grace_period: 30s
     stop_signal: SIGTERM
-    deploy:
-      resources:
-        limits:
-          memory: 3g
     extra_hosts:
       - "host.docker.internal:host-gateway"
     ports:
-      - "${STAGING_GO_HTTP_PORT:-82}:80"
-      - "${STAGING_GO_MQTT_PORT:-1885}:1883"
+      - "${STAGING_GO_HTTP_PORT:-80}:80"
+      - "${STAGING_GO_MQTT_PORT:-1883}:1883"
       - "6060:6060"   # pprof server
       - "6061:6061"   # pprof ingestor
     volumes:

docker/entrypoint-go.sh

@@ -15,9 +15,16 @@ if [ -f /app/data/theme.json ]; then
 fi
 
 SUPERVISORD_CONF="/etc/supervisor/conf.d/supervisord.conf"
-if [ "${DISABLE_MOSQUITTO:-false}" = "true" ]; then
+if [ "${DISABLE_MOSQUITTO:-false}" = "true" ] && [ "${DISABLE_CADDY:-false}" = "true" ]; then
+  echo "[config] internal MQTT broker disabled (DISABLE_MOSQUITTO=true)"
+  echo "[config] Caddy reverse proxy disabled (DISABLE_CADDY=true)"
+  SUPERVISORD_CONF="/etc/supervisor/conf.d/supervisord-no-mosquitto-no-caddy.conf"
+elif [ "${DISABLE_MOSQUITTO:-false}" = "true" ]; then
   echo "[config] internal MQTT broker disabled (DISABLE_MOSQUITTO=true)"
   SUPERVISORD_CONF="/etc/supervisor/conf.d/supervisord-no-mosquitto.conf"
+elif [ "${DISABLE_CADDY:-false}" = "true" ]; then
+  echo "[config] Caddy reverse proxy disabled (DISABLE_CADDY=true)"
+  SUPERVISORD_CONF="/etc/supervisor/conf.d/supervisord-no-caddy.conf"
 fi
 
 exec /usr/bin/supervisord -c "$SUPERVISORD_CONF"

docker/supervisord-go-no-caddy.conf

@@ -0,0 +1,43 @@
+[supervisord]
+nodaemon=true
+user=root
+logfile=/dev/stdout
+logfile_maxbytes=0
+pidfile=/var/run/supervisord.pid
+
+[program:mosquitto]
+command=/usr/sbin/mosquitto -c /etc/mosquitto/mosquitto.conf
+autostart=true
+autorestart=true
+stdout_logfile=/dev/stdout
+stdout_logfile_maxbytes=0
+stderr_logfile=/dev/stderr
+stderr_logfile_maxbytes=0
+
+[program:corescope-ingestor]
+command=/app/corescope-ingestor -config /app/config.json
+directory=/app
+autostart=true
+autorestart=true
+startretries=10
+startsecs=2
+stopsignal=TERM
+stopwaitsecs=20
+stdout_logfile=/dev/stdout
+stdout_logfile_maxbytes=0
+stderr_logfile=/dev/stderr
+stderr_logfile_maxbytes=0
+
+[program:corescope-server]
+command=/app/corescope-server -config-dir /app -db /app/data/meshcore.db -public /app/public -port 3000
+directory=/app
+autostart=true
+autorestart=true
+startretries=10
+startsecs=2
+stopsignal=TERM
+stopwaitsecs=20
+stdout_logfile=/dev/stdout
+stdout_logfile_maxbytes=0
+stderr_logfile=/dev/stderr
+stderr_logfile_maxbytes=0

docker/supervisord-go-no-mosquitto-no-caddy.conf

@@ -0,0 +1,34 @@
+[supervisord]
+nodaemon=true
+user=root
+logfile=/dev/stdout
+logfile_maxbytes=0
+pidfile=/var/run/supervisord.pid
+
+[program:corescope-ingestor]
+command=/app/corescope-ingestor -config /app/config.json
+directory=/app
+autostart=true
+autorestart=true
+startretries=10
+startsecs=2
+stopsignal=TERM
+stopwaitsecs=20
+stdout_logfile=/dev/stdout
+stdout_logfile_maxbytes=0
+stderr_logfile=/dev/stderr
+stderr_logfile_maxbytes=0
+
+[program:corescope-server]
+command=/app/corescope-server -config-dir /app -db /app/data/meshcore.db -public /app/public -port 3000
+directory=/app
+autostart=true
+autorestart=true
+startretries=10
+startsecs=2
+stopsignal=TERM
+stopwaitsecs=20
+stdout_logfile=/dev/stdout
+stdout_logfile_maxbytes=0
+stderr_logfile=/dev/stderr
+stderr_logfile_maxbytes=0

docs/RELEASE-NOTES-v3.4.md

@@ -0,0 +1,47 @@
+# CoreScope v3.4 Release Notes
+
+**The neighbor affinity release.** CoreScope now understands how nodes relate to each other — not just that they exist, but how strongly they're connected. This powers smarter hop resolution, richer node detail pages, and a new graph visualization in analytics.
+
+---
+
+## 🎯 Features
+
+### Neighbor Affinity System (7 milestones)
+A complete neighbor relationship engine, from backend graph building to frontend visualization:
+
+- **Affinity graph builder** — computes neighbor relationships and connection strength from packet traffic (#507)
+- **Affinity API endpoints** — REST endpoints to query neighbor data (#508)
+- **Show Neighbors via affinity API** — the existing Show Neighbors feature now uses real affinity data instead of raw packet heuristics (#512, fixes #484)
+- **Affinity-aware hop resolution** — hop resolver uses neighbor affinity to pick better paths (#511)
+- **Node detail neighbors section** — dedicated neighbors panel on the node detail page (#510)
+- **Affinity debugging tools** — inspect and troubleshoot affinity calculations (#521)
+- **Neighbor graph visualization** — interactive neighbor graph in the analytics tab (#513)
+
+### Customizer v2
+- Event-driven state management replaces the old imperative approach — cleaner, more predictable theme/config updates (#503)
+
+---
+
+## 🐛 Bug Fixes
+
+- **Stale parsed cache on observation packets** — observation packets now correctly invalidate the JSON parse cache (#505)
+- **Null-guard rAF callbacks** — live page no longer crashes when `requestAnimationFrame` callbacks fire after cleanup (#506)
+- **Customizer v2 phantom overrides** — fixed phantom config entries, missing defaults, and stale dark mode state (#520)
+- **Neighbor affinity empty results** — fixed pubKey field name mismatch causing empty affinity graphs (#524)
+- **Home defaults in server theme** — server-side theme config now includes home page defaults (#526)
+- **Neighbor UI crash + dark mode** — fixed Show Neighbors crash and improved dark mode contrast (#527)
+- **Home page steps + FAQ** — both steps AND FAQ now render correctly on the home page (#529)
+
+---
+
+## ⚡ Performance
+
+- **Cached JSON.parse for packet data** — packet payloads are parsed once and cached, avoiding redundant `JSON.parse` calls on repeated access (#400)
+
+---
+
+## Known Limitations
+
+- **Affinity graph scales with traffic volume** — networks with very low packet rates may show weak or missing neighbor relationships until enough data accumulates
+- **Debugging tools are developer-facing** — the affinity debug panel (#521) is functional but not polished for end-user consumption
+- **Customizer v2 migration** — custom themes saved under v1 may need to be re-applied after upgrade

docs/deployment.md

@@ -0,0 +1,447 @@
+# CoreScope Deployment Guide
+
+Comprehensive guide to deploying and operating CoreScope. For a quick start, see [DEPLOY.md](../DEPLOY.md).
+
+## Table of Contents
+
+- [System Requirements](#system-requirements)
+- [Docker Deployment](#docker-deployment)
+- [Configuration Reference](#configuration-reference)
+- [MQTT Setup](#mqtt-setup)
+- [TLS / HTTPS](#tls--https)
+- [Monitoring & Health Checks](#monitoring--health-checks)
+- [Backup & Restore](#backup--restore)
+- [Troubleshooting](#troubleshooting)
+
+---
+
+## System Requirements
+
+| Resource | Minimum | Recommended |
+|----------|---------|-------------|
+| RAM | 256 MB | 512 MB+ |
+| Disk | 500 MB (image + DB) | 2 GB+ for long-term data |
+| CPU | 1 core | 2+ cores |
+| Architecture | `linux/amd64`, `linux/arm64` | — |
+| Docker | 20.10+ | Latest stable |
+
+CoreScope runs well on Raspberry Pi 4/5 (ARM64). The Go server uses ~300 MB RAM for 56K+ packets.
+
+---
+
+## Docker Deployment
+
+### Quick Start (one command)
+
+```bash
+docker run -d --name corescope \
+  -p 80:80 \
+  -v corescope-data:/app/data \
+  ghcr.io/kpa-clawbot/corescope:latest
+```
+
+Open `http://localhost` — you'll see an empty dashboard ready to receive packets.
+
+No `config.json` is required. The server starts with sensible defaults:
+- HTTP on port 3000 (Caddy proxies port 80 → 3000 internally)
+- Internal Mosquitto MQTT broker on port 1883
+- Ingestor connects to `mqtt://localhost:1883` automatically
+- SQLite database at `/app/data/meshcore.db`
+
+### Docker Compose (recommended for production)
+
+Download the example compose file:
+
+```bash
+curl -sL https://raw.githubusercontent.com/Kpa-clawbot/CoreScope/master/docker-compose.example.yml \
+  -o docker-compose.yml
+docker compose up -d
+```
+
+#### Compose environment variables
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `HTTP_PORT` | `80` | Host port for the web UI |
+| `DATA_DIR` | `./data` | Host path for persistent data |
+| `DISABLE_MOSQUITTO` | `false` | Set `true` to use an external MQTT broker |
+
+### Image tags
+
+| Tag | Use case |
+|-----|----------|
+| `v3.4.1` | Pinned release — recommended for production |
+| `v3.4` | Latest patch in the v3.4.x series |
+| `v3` | Latest minor+patch in v3.x |
+| `latest` | Latest release tag |
+| `edge` | Built from master on every push — unstable |
+
+### Updating
+
+```bash
+docker compose pull
+docker compose up -d
+```
+
+For `docker run` users:
+
+```bash
+docker pull ghcr.io/kpa-clawbot/corescope:latest
+docker stop corescope && docker rm corescope
+docker run -d --name corescope ... # same flags as before
+```
+
+Data is preserved in the volume — updates are non-destructive.
+
+---
+
+## Configuration Reference
+
+CoreScope uses a layered configuration system (highest priority wins):
+
+1. **Environment variables** — `MQTT_BROKER`, `DB_PATH`, etc.
+2. **`/app/data/config.json`** — full config file (volume-mounted)
+3. **Built-in defaults** — work out of the box with no config
+
+### Environment variable overrides
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `MQTT_BROKER` | `mqtt://localhost:1883` | MQTT broker URL (overrides config file) |
+| `MQTT_TOPIC` | `meshcore/#` | MQTT topic subscription pattern |
+| `DB_PATH` | `data/meshcore.db` | SQLite database path |
+| `DISABLE_MOSQUITTO` | `false` | Skip the internal Mosquitto broker |
+
+### config.json
+
+For advanced configuration, create a `config.json` and mount it at `/app/data/config.json`:
+
+```bash
+docker run -d --name corescope \
+  -p 80:80 \
+  -v corescope-data:/app/data \
+  -v ./config.json:/app/data/config.json:ro \
+  ghcr.io/kpa-clawbot/corescope:latest
+```
+
+See `config.example.json` in the repository for all available options including:
+- MQTT sources (multiple brokers)
+- Channel encryption keys
+- Branding and theming
+- Health thresholds
+- Region filters
+- Retention policies
+- Geo-filtering
+
+---
+
+## MQTT Setup
+
+CoreScope receives MeshCore packets via MQTT. The container ships with an internal Mosquitto broker — no setup needed for basic use.
+
+### Internal broker (default)
+
+The built-in Mosquitto broker listens on port 1883 inside the container. Point your MeshCore gateways at it:
+
+```bash
+# Expose MQTT port for external gateways
+docker run -d --name corescope \
+  -p 80:80 -p 1883:1883 \
+  -v corescope-data:/app/data \
+  ghcr.io/kpa-clawbot/corescope:latest
+```
+
+### External broker
+
+To use your own MQTT broker (Mosquitto, EMQX, HiveMQ, etc.):
+
+1. Disable the internal broker:
+   ```bash
+   -e DISABLE_MOSQUITTO=true
+   ```
+
+2. Point the ingestor at your broker:
+   ```bash
+   -e MQTT_BROKER=mqtt://your-broker:1883
+   ```
+
+   Or via `config.json`:
+   ```json
+   {
+     "mqttSources": [
+       {
+         "name": "my-broker",
+         "broker": "mqtt://your-broker:1883",
+         "username": "user",
+         "password": "pass",
+         "topics": ["meshcore/#"]
+       }
+     ]
+   }
+   ```
+
+### Multiple brokers
+
+CoreScope can connect to multiple MQTT brokers simultaneously:
+
+```json
+{
+  "mqttSources": [
+    {
+      "name": "local",
+      "broker": "mqtt://localhost:1883",
+      "topics": ["meshcore/#"]
+    },
+    {
+      "name": "remote",
+      "broker": "mqtts://remote-broker:8883",
+      "username": "reader",
+      "password": "secret",
+      "topics": ["meshcore/+/+/packets"]
+    }
+  ]
+}
+```
+
+### MQTT topic format
+
+MeshCore gateways typically publish to `meshcore/<gateway>/<region>/packets`. The default subscription `meshcore/#` catches all of them.
+
+---
+
+## TLS / HTTPS
+
+### Option 1: External reverse proxy (recommended)
+
+Run CoreScope behind nginx, Traefik, or Cloudflare Tunnel for TLS termination:
+
+```nginx
+# nginx example
+server {
+    listen 443 ssl;
+    server_name corescope.example.com;
+
+    ssl_certificate /etc/ssl/certs/corescope.pem;
+    ssl_certificate_key /etc/ssl/private/corescope.key;
+
+    location / {
+        proxy_pass http://localhost:80;
+        proxy_http_version 1.1;
+        proxy_set_header Upgrade $http_upgrade;
+        proxy_set_header Connection "upgrade";
+        proxy_set_header Host $host;
+    }
+}
+```
+
+The `Upgrade` and `Connection` headers are required for WebSocket support.
+
+### Option 2: Built-in Caddy (auto-TLS)
+
+The container includes Caddy for automatic Let's Encrypt certificates:
+
+1. Create a Caddyfile:
+   ```
+   corescope.example.com {
+     reverse_proxy localhost:3000
+   }
+   ```
+
+2. Mount it and expose TLS ports:
+   ```bash
+   docker run -d --name corescope \
+     -p 80:80 -p 443:443 \
+     -v corescope-data:/app/data \
+     -v caddy-certs:/data/caddy \
+     -v ./Caddyfile:/etc/caddy/Caddyfile:ro \
+     ghcr.io/kpa-clawbot/corescope:latest
+   ```
+
+Caddy handles certificate issuance and renewal automatically.
+
+---
+
+## API Documentation
+
+CoreScope auto-generates an OpenAPI 3.0 specification from its route definitions. The spec is always in sync with the running server — no manual maintenance required.
+
+### Endpoints
+
+| URL | Description |
+|-----|-------------|
+| `/api/spec` | OpenAPI 3.0 JSON schema — machine-readable API definition |
+| `/api/docs` | Interactive Swagger UI — browse and test all 40+ endpoints |
+
+### Usage
+
+**Browse the API interactively:**
+```
+http://your-instance/api/docs
+```
+
+**Fetch the spec programmatically:**
+```bash
+curl http://your-instance/api/spec | jq .
+```
+
+**For bot/integration developers:** The spec includes all request parameters, response schemas, and example values. Import it into Postman, Insomnia, or any OpenAPI-compatible tool.
+
+### Public instance
+The live instance at [analyzer.00id.net](https://analyzer.00id.net) has all API endpoints publicly accessible:
+- Spec: [analyzer.00id.net/api/spec](https://analyzer.00id.net/api/spec)
+- Docs: [analyzer.00id.net/api/docs](https://analyzer.00id.net/api/docs)
+
+---
+
+## Monitoring & Health Checks
+
+### Docker health check
+
+The container includes a built-in health check that hits `/api/stats`:
+
+```bash
+docker inspect --format='{{.State.Health.Status}}' corescope
+```
+
+Docker reports `healthy` or `unhealthy` automatically. The check runs every 30 seconds.
+
+### Manual health check
+
+```bash
+curl -f http://localhost/api/stats
+```
+
+Returns JSON with packet counts, node counts, and version info:
+
+```json
+{
+  "totalPackets": 56234,
+  "totalNodes": 142,
+  "totalObservers": 12,
+  "packetsLastHour": 830,
+  "packetsLast24h": 19644,
+  "engine": "go",
+  "version": "v3.4.1"
+}
+```
+
+### Log monitoring
+
+```bash
+# All logs
+docker compose logs -f
+
+# Server only
+docker compose logs -f | grep '\[server\]'
+
+# Ingestor only
+docker compose logs -f | grep '\[ingestor\]'
+```
+
+### Resource monitoring
+
+```bash
+docker stats corescope
+```
+
+---
+
+## Backup & Restore
+
+### Backup
+
+All persistent data lives in `/app/data`. The critical file is the SQLite database:
+
+```bash
+# Copy from the Docker volume
+docker cp corescope:/app/data/meshcore.db ./backup-$(date +%Y%m%d).db
+
+# Or if using a bind mount
+cp ./data/meshcore.db ./backup-$(date +%Y%m%d).db
+```
+
+Optional files to back up:
+- `config.json` — custom configuration
+- `theme.json` — custom theme/branding
+
+### Restore
+
+```bash
+# Stop the container
+docker stop corescope
+
+# Replace the database
+docker cp ./backup.db corescope:/app/data/meshcore.db
+
+# Restart
+docker start corescope
+```
+
+### Automated backups
+
+```bash
+# cron: daily backup at 3 AM, keep 7 days
+0 3 * * * docker cp corescope:/app/data/meshcore.db /backups/corescope-$(date +\%Y\%m\%d).db && find /backups -name "corescope-*.db" -mtime +7 -delete
+```
+
+---
+
+## Troubleshooting
+
+### Container starts but dashboard is empty
+
+This is normal on first start with no MQTT sources configured. The dashboard shows data once packets arrive via MQTT. Either:
+- Point a MeshCore gateway at the container's MQTT broker (port 1883)
+- Configure an external MQTT source in `config.json`
+
+### "no MQTT connections established" in logs
+
+The ingestor couldn't connect to any MQTT broker. Check:
+1. Is the internal Mosquitto running? (`DISABLE_MOSQUITTO` should be `false`)
+2. Is the external broker reachable? Test with `mosquitto_sub -h broker -t meshcore/#`
+3. Are credentials correct in `config.json`?
+
+### WebSocket disconnects / real-time updates stop
+
+If behind a reverse proxy, ensure WebSocket upgrade headers are forwarded:
+```nginx
+proxy_http_version 1.1;
+proxy_set_header Upgrade $http_upgrade;
+proxy_set_header Connection "upgrade";
+```
+
+Also check proxy timeouts — set them to at least 300s for long-lived WebSocket connections.
+
+### High memory usage
+
+The in-memory packet store grows with retained packets. Configure retention limits in `config.json`:
+
+```json
+{
+  "packetStore": {
+    "retentionHours": 24,
+    "maxMemoryMB": 512
+  },
+  "retention": {
+    "nodeDays": 7,
+    "packetDays": 30
+  }
+}
+```
+
+### Database locked errors
+
+SQLite doesn't support concurrent writers well. Ensure only one CoreScope instance accesses the database file. If running multiple containers, each needs its own database.
+
+### Container unhealthy
+
+Check logs: `docker compose logs --tail 50`. Common causes:
+- Port 3000 already in use inside the container
+- Database file permissions (must be writable by the container user)
+- Corrupted database — restore from backup
+
+### ARM / Raspberry Pi issues
+
+- Use `linux/arm64` images (Pi 4 and 5). Pi 3 (armv7) is not supported.
+- First pull may be slow — the multi-arch manifest selects the right image automatically.
+- If memory is tight, set `packetStore.maxMemoryMB` to limit RAM usage.

docs/proposals/ecb-frequency-analysis.md

@@ -0,0 +1,403 @@
+# Security Analysis: MeshCore Channel Encryption
+
+## Scope
+
+This analysis covers MeshCore's encryption vulnerabilities in order of practical severity. Section 1 addresses PSK brute-force (the highest-priority practical threat). Sections 2–9 cover AES-128-ECB structural weaknesses. Section 8 covers TXT_MSG. All claims are derived from firmware source (`BaseChatMesh.cpp`, `Utils.cpp`, `Mesh.cpp`, `MeshCore.h`) unless explicitly marked as conjecture.
+
+## 1. PSK Brute-Force with Timestamp Oracle
+
+### 1.1 The No-KDF Design
+
+MeshCore channel PSKs are base64-decoded directly into AES-128 keys with no key derivation function (from `BaseChatMesh::addChannel()`):
+
+```cpp
+int len = decode_base64((unsigned char *) psk_base64, strlen(psk_base64), dest->channel.secret);
+```
+
+No PBKDF2, scrypt, argon2, or HKDF is applied. The base64-decoded bytes ARE the AES key. This means:
+
+1. **Human-memorable passphrases have drastically reduced entropy.** If a user types "SecretChannel" as their PSK, the base64-decoded output is ~10 bytes of ASCII-range values. The key space is determined by the passphrase complexity, not by AES-128's theoretical 2^128 key space.
+
+2. **Short passphrases produce short keys.** `decode_base64` maps every 4 base64 characters to 3 bytes. A passphrase shorter than ~22 base64 characters produces fewer than 16 bytes, and the remainder of the 16-byte key buffer depends on whatever was previously in memory (likely zeros from initialization). An 8-character passphrase decodes to only 6 bytes — the effective key space may be as low as 2^48.
+
+3. **No salt.** Identical passphrases on different meshes produce identical keys. A single precomputed dictionary attack works globally against all MeshCore deployments.
+
+### 1.2 Timestamp as Known-Plaintext Oracle
+
+Every GRP_TXT plaintext begins with a structured, largely predictable header:
+
+```
+Block 0: [TS₀][TS₁][TS₂][TS₃][0x00][sender_name][: ][message_start...]
+```
+
+An attacker who captures a single packet can verify a candidate PSK by:
+1. Decrypting block 0 with the candidate key
+2. Checking if bytes 0–3 produce a plausible Unix timestamp (within a reasonable window of the capture time)
+3. Checking if byte 4 is 0x00 (TXT_TYPE_PLAIN)
+4. Optionally checking if bytes 5+ are valid ASCII (sender name)
+
+The timestamp alone constrains the search: a ±1-hour window around capture time yields ~7,200 valid timestamps out of 2^32 possibilities — a false-positive rate of ~1.7×10^-6. Combined with the type byte and ASCII sender-name check, false positives are effectively zero. **One captured packet is sufficient for definitive key verification.**
+
+### 1.3 Attack Cost Estimates
+
+Hardware assumption: commodity GPU (e.g., RTX 4090) performing ~10 billion AES-128-ECB block encryptions per second. This is conservative — optimized implementations achieve higher throughput.
+
+| Passphrase style | Search space | Time at 10^10 AES/sec |
+|---|---|---|
+| Single common English word (10K-word list) | ~10^4 | microseconds |
+| Single English word (170K full dictionary) | ~1.7×10^5 | microseconds |
+| Two concatenated common words | ~10^8 | ~10 milliseconds |
+| Three concatenated common words | ~10^12 | ~100 seconds (~2 min) |
+| Four random common words (Diceware-style) | ~10^16 | ~10^6 seconds (~12 days) |
+| Random 8-char alphanumeric (62^8) | ~2.2×10^14 | ~22,000 seconds (~6 hours) |
+| Random 12-char alphanumeric (62^12) | ~3.2×10^21 | ~10^11 seconds (infeasible) |
+| Full random 16-byte key (2^128) | ~3.4×10^38 | infeasible |
+
+**Important caveats on search space:**
+- Dictionary sizes vary: "common English words" ≈ 3K–10K; full dictionary ≈ 170K. Estimates above use 10K for "common" lists.
+- Humans do not choose words uniformly. Zipf's law applies — a small fraction of words account for most selections. The effective entropy is **lower** than the uniform assumption, making attacks faster.
+- Concatenation without separators creates ambiguity ("therapist" = "therapist" or "the"+"rapist"), but this marginally reduces search space rather than increasing it.
+- Multi-channel amortization: an attacker can test each candidate against ALL captured channels simultaneously, paying the AES cost once per candidate.
+
+### 1.4 Attack Properties
+
+- **Offline attack.** No rate limiting, no lockout, no detection. The attacker works entirely on captured ciphertext.
+- **Single-packet verification.** One GRP_TXT packet is sufficient. No need to collect multiple messages.
+- **No KDF stretching.** Each candidate requires exactly one AES-128 block decryption (16 bytes), not thousands of hash iterations.
+- **Global applicability.** No salt means precomputed tables work across all MeshCore deployments using the same passphrase.
+- **Side-channel exposure.** Since the PSK IS the key (no KDF), any AES key-schedule side-channel directly reveals the passphrase. PSK reuse across systems (e.g., same passphrase for MeshCore and WiFi) means compromise of one compromises both.
+
+### 1.5 Severity Assessment
+
+**PSK brute-force is the #1 practical threat to MeshCore channel confidentiality.** Unlike ECB frequency analysis (§5), which requires hundreds of captured messages with repeated content, PSK brute-force requires a single captured packet and succeeds whenever users choose human-memorable passphrases — which is the common case for manually-configured channels.
+
+Any channel using a passphrase of 3 or fewer common words, or any alphanumeric string shorter than 12 characters, should be considered **vulnerable to offline brute-force within hours to days** using commodity hardware.
+
+### 1.6 Recommended Mitigations
+
+**Priority 0 (Critical):** Apply a memory-hard KDF (argon2id preferred; scrypt or PBKDF2 with ≥100K iterations as fallback) to derive the AES key from the passphrase. This transforms each candidate test from ~1 nanosecond to ~100 milliseconds, increasing attack cost by a factor of ~10^8.
+
+**Priority 0a:** Add a per-channel salt (random bytes stored alongside the channel config) to prevent precomputed/global attacks.
+
+**Priority 0b:** Document that channel PSKs should be random 16-byte keys (e.g., generated with `openssl rand -base64 22`), not human-memorable passphrases. This is a stopgap until KDF support is added.
+
+## 2. How Encryption Works
+
+### Constants (from `MeshCore.h`)
+- `CIPHER_KEY_SIZE = 16` (AES-128)
+- `PUB_KEY_SIZE = 32`
+- `CIPHER_MAC_SIZE` = HMAC-SHA256 truncated output size
+
+### encrypt() (from `Utils.cpp`)
+AES-128-ECB, block-by-block. No IV, no counter, no chaining:
+```cpp
+aes.setKey(shared_secret, CIPHER_KEY_SIZE);  // first 16 bytes of shared_secret
+while (src_len >= 16) {
+    aes.encryptBlock(dp, src);  // each 16-byte block independently
+    dp += 16; src += 16; src_len -= 16;
+}
+if (src_len > 0) {  // partial final block
+    uint8_t tmp[16];
+    memset(tmp, 0, 16);   // zero-fill
+    memcpy(tmp, src, src_len);  // copy remaining bytes
+    aes.encryptBlock(dp, tmp);
+}
+```
+
+### encryptThenMAC() (from `Utils.cpp`)
+```cpp
+int enc_len = encrypt(shared_secret, dest + CIPHER_MAC_SIZE, src, src_len);
+SHA256 sha;
+sha.resetHMAC(shared_secret, PUB_KEY_SIZE);   // HMAC uses full 32 bytes
+sha.update(dest + CIPHER_MAC_SIZE, enc_len);
+sha.finalizeHMAC(shared_secret, PUB_KEY_SIZE, dest, CIPHER_MAC_SIZE);
+```
+
+**Key reuse flaw:** The same `shared_secret` buffer serves both AES and HMAC. AES uses `shared_secret[0..15]` (first 16 bytes). HMAC uses `shared_secret[0..31]` (full 32 bytes). The AES key is a prefix of the HMAC key. See §7 for implications.
+
+### GRP_TXT Plaintext Construction (from `BaseChatMesh::sendGroupMessage()`)
+
+```cpp
+memcpy(temp, &timestamp, 4);          // bytes 0-3: Unix timestamp (seconds)
+temp[4] = 0;                           // byte 4: TXT_TYPE_PLAIN
+sprintf((char *)&temp[5], "%s: ", sender_name);  // bytes 5+: "SenderName: "
+char *ep = strchr((char *)&temp[5], 0);
+int prefix_len = ep - (char *)&temp[5];           // length of "SenderName: "
+memcpy(ep, text, text_len);            // message text (no null terminator)
+ep[text_len] = 0;                      // null written AFTER data boundary
+// data_len passed to encrypt = 5 + prefix_len + text_len
+```
+
+**The null terminator is NOT part of the encrypted data length.** The call to `createGroupDatagram` passes length `5 + prefix_len + text_len`. The null at `ep[text_len]` is written to the buffer but is beyond `data_len`. In the final partial block, `encrypt()` zero-fills with `memset(tmp, 0, 16)` before copying the remaining bytes — so a zero byte appears at the position where the null would be, but this is an artifact of zero-padding, not an explicit null in the plaintext.
+
+On the receiving side, this is confirmed:
+```cpp
+data[len] = 0; // need to make a C string again, with null terminator
+```
+The receiver must re-add the null after decryption.
+
+## 3. Block Layout Analysis
+
+### Notation
+
+Let `N` = length of sender name. Then:
+- `prefix_len` = N + 2 (for ": " suffix from `sprintf("%s: ", sender_name)`)
+- Header overhead = 4 (timestamp) + 1 (type) + prefix_len = N + 7 bytes
+- Message text begins at byte offset N + 7
+
+### Block 0
+
+Block 0 = bytes 0–15 of plaintext:
+```
+[TS₀][TS₁][TS₂][TS₃][0x00][sender_name: ][...message start...]
+```
+
+The first 9 − N bytes of message text fit in block 0 (when N < 9). For N ≥ 9, no message text fits in block 0.
+
+### Boundary Condition: Sender Name ≥ 12 Characters
+
+When N ≥ 12, the header overhead (N + 7 ≥ 19) exceeds 16 bytes. The header itself spills into block 1:
+
+**Example: sender name "LongUserName1" (N = 13), message "hi":**
+```
+Header = 13 + 7 = 20 bytes. Total plaintext = 20 + 2 = 22 bytes.
+
+Block 0 (bytes 0-15):  [TS₀][TS₁][TS₂][TS₃][0x00][L][o][n][g][U][s][e][r][N][a][m]
+Block 1 (bytes 16-31): [e][1][:][space][h][i][0x00 ×10]  ← zero-padded partial block
+```
+
+Block 1 here contains the tail of the sender name, the ": " separator, message text, AND zero-padding. For sender names of length 12–15, block 1 is a mix of header and message — **it is NOT "pure message text."**
+
+For sender names ≥ 16, blocks 0 and 1 are both pure header, and message text doesn't begin until block 1 or later.
+
+### General Block Content Table
+
+| Sender name length N | Header bytes | Message starts at byte | Block 0 content | Block 1+ content |
+|---|---|---|---|---|
+| 1–8 | 8–15 | 8–15 | timestamp + header + message start | message text + zero-pad |
+| 9–11 | 16–18 | 16–18 | timestamp + header (no message) | header tail + message + zero-pad |
+| 12–15 | 19–22 | 19–22 | timestamp + partial header | header tail + message + zero-pad |
+| ≥16 | ≥23 | ≥23 | timestamp + partial header | header continuation, then message |
+
+### Typical Case (N = 5, e.g. "Alice")
+
+Header = 12 bytes. Message starts at byte 12. Block 0 holds 4 bytes of message text.
+
+```
+Message "hello world" (11 chars). Total plaintext = 12 + 11 = 23 bytes.
+
+Block 0 (bytes 0-15):  [TS₀][TS₁][TS₂][TS₃][0x00][A][l][i][c][e][:][space][h][e][l][l]
+Block 1 (bytes 16-22): [o][space][w][o][r][l][d] → padded to: [o][space][w][o][r][l][d][0×9]
+```
+
+Block 1 contains 7 bytes of message text and 9 bytes of zero-padding.
+
+## 4. Attack Surface by Block Position
+
+### Block 0: Accidental Nonce from Timestamp
+
+The 4-byte Unix timestamp in bytes 0–3 acts as an **accidental nonce** — it was included "mostly as an extra blob to help make packet_hash unique" (per firmware comment), not as a cryptographic countermeasure against ECB determinism. Nevertheless, it has the effect of making block 0's plaintext vary per message.
+
+**Precision on uniqueness:** Block 0 is unique per (sender, timestamp-second) pair, not per message. Two messages from the same sender within the same second, on the same channel, with the same type byte, produce identical block 0 plaintext and therefore identical block 0 ciphertext. At typical mesh chat rates, same-second collisions are rare but not impossible for automated/scripted senders.
+
+**Known-plaintext observation:** Bytes 4–15 of block 0 are largely predictable per sender (type byte is always 0x00 for plain text; sender name and ": " are static). The timestamp is predictable within a window (Unix seconds). An attacker who knows the sender name and approximate time can compute all 16 plaintext bytes of block 0. However, **AES-128 is resistant to known-plaintext attacks** — knowing plaintext-ciphertext pairs for block 0 does not help recover the key or decrypt other blocks.
+
+### Blocks 1+: Deterministic ECB (for short sender names)
+
+When the sender name is short enough that the header fits in block 0 (N ≤ 8), blocks 1+ contain **only message text and zero-padding.** No timestamp, no nonce, no per-message varying data. Identical message text at the same block offset produces identical ciphertext, always.
+
+When N ≥ 9, block 1 contains header spillover, which includes static sender name bytes — these vary per sender but not per message, so block 1 is still deterministic for a given sender once the header portion is fixed.
+
+**The fundamental ECB property:** For any block beyond the timestamp's reach, `E_K(P) = E_K(P)`. Same plaintext block → same ciphertext block, regardless of when or how many times it's sent.
+
+### Partial Final Block: Strongest Attack Target
+
+The final block of every message is zero-padded by `encrypt()` to 16 bytes. The padding bytes are deterministic and known (always 0x00). For a message whose final block contains `B` bytes of actual content:
+
+- `B` bytes are unknown message text
+- `16 - B` bytes are known zeros
+
+When B is small (short final fragment), most of the block is known plaintext. For B = 1, the attacker knows 15 of 16 bytes — only 256 possible plaintext blocks exist. This means:
+
+- **The final block has at most 2^(8B) possible plaintexts** (versus 2^128 for a full unknown block)
+- For B ≤ 4, there are ≤ 2^32 possibilities — a small enough space for dictionary attacks given enough ciphertext samples
+- The attacker can precompute all possible final-block plaintexts for small B values and match against observed ciphertext blocks
+
+This makes the partial final block a **stronger frequency analysis target** than interior blocks, where all 16 bytes may be unknown text.
+
+## 5. Feasible Attack Scenarios
+
+### 4.1 Block Frequency Analysis on Blocks 1+
+
+**Preconditions (all must hold):**
+1. Attacker can observe encrypted GRP_TXT packets (passive radio capture)
+2. Messages from the same sender (or senders with identical name lengths — same block alignment)
+3. Messages long enough to produce blocks beyond block 0 (text > 9 − N chars)
+4. Sufficient message volume with repeated content at the same block positions
+
+**Method:**
+1. Collect GRP_TXT packets, group by sender hash
+2. Decompose encrypted payloads into 16-byte blocks (after stripping HMAC prefix)
+3. Discard block 0 (timestamp-varying)
+4. Build frequency tables for blocks 1, 2, 3, etc., per sender
+5. Match high-frequency ciphertext blocks against expected plaintext distributions
+
+**Practical constraints limiting this attack:**
+- LoRa bandwidth severely limits message length. Most mesh chat messages are short — many fit entirely within block 0 (≤ 9 − N chars of text), yielding zero analyzable blocks.
+- Messages that spill into block 1+ tend to be longer and more varied — fewer repeated patterns.
+- The attack requires repeated identical 16-byte-aligned text fragments from the same sender over time.
+
+**Conditions under which this attack succeeds:** Automated or scripted senders transmitting repetitive messages longer than block 0 capacity, on a channel with a static PSK, over an extended collection period. For human-typed conversational messages with typical length and variety, the number of repeated block 1+ patterns is likely too low for meaningful frequency analysis. (This is an empirical claim that depends on actual traffic patterns — no formal bound is established here.)
+
+### 4.2 Partial Final Block Dictionary Attack
+
+**Preconditions:**
+1. Attacker knows (or can estimate) the message length modulo 16
+2. Final block has few content bytes (B ≤ 4)
+
+**Method:** Enumerate all 2^(8B) candidate plaintexts for the final block. Since AES-ECB is deterministic with a fixed key, the attacker can build a lookup table: if they ever observe a ciphertext block matching one of the candidates in a known-plaintext scenario (e.g., from a leaked or guessed message), they can identify which final-block value corresponds to which ciphertext.
+
+**Limitation:** Without the key, the attacker cannot compute E_K(candidate) directly. The attack requires collecting enough ciphertext final blocks to perform frequency analysis within the reduced plaintext space. With only 256 possibilities (B=1), convergence is fast given sufficient samples.
+
+### 4.3 Cross-Sender Correlation
+
+Senders with identical name lengths produce identical block alignments. Messages from "Alice" (N=5) and "Bobby" (N=5) place message text at the same byte offsets. If both send the same message, their blocks 1+ are identical ciphertext — **but only if they share the same channel PSK** (same AES key). On the same channel, this enables cross-sender frequency analysis within same-name-length groups.
+
+### 4.4 Message Length Leakage
+
+Ciphertext length = ⌈(5 + prefix_len + text_len) / 16⌉ × 16 bytes. This reveals the message text length within a 16-byte window (not 15, because the block count is the observable quantity). Not ECB-specific — any block cipher without constant-length padding leaks this.
+
+### 4.5 Replay Attacks
+
+`encryptThenMAC()` authenticates the ciphertext, but if the mesh doesn't track previously-seen packet MACs, captured packets can be replayed. The embedded timestamp may be checked for staleness — this requires firmware verification beyond the scope of this analysis.
+
+### 4.6 No Forward Secrecy
+
+Channel PSKs are static and shared among all participants. ECDH shared secrets for direct messages are also static (no ephemeral key exchange). Compromise of any key decrypts all past and future traffic encrypted under that key.
+
+## 6. What Known-Plaintext Does NOT Achieve
+
+AES-128 is designed to resist known-plaintext attacks. An attacker who knows the full plaintext and ciphertext of block 0 (or any block) **cannot**:
+- Recover the AES key
+- Decrypt other blocks encrypted under the same key
+- Derive any information about other plaintexts from their ciphertexts
+
+The ECB weakness is **determinism** (identical plaintext → identical ciphertext), not key recovery. The attacks in §5 exploit pattern matching and frequency analysis, not cryptanalysis of AES itself.
+
+## 7. HMAC Key Reuse: Cryptographic Design Flaw
+
+From `encryptThenMAC()`:
+- AES key: `shared_secret[0..15]` (CIPHER_KEY_SIZE = 16)
+- HMAC key: `shared_secret[0..31]` (PUB_KEY_SIZE = 32)
+
+The AES key is the first half of the HMAC key. Both are derived from the same `shared_secret` — for channels, this is the PSK; for direct messages, the ECDH shared secret.
+
+**Why this matters:**
+1. **Violated key separation principle.** Standard practice dictates that encryption and authentication keys must be independent. Using overlapping portions of the same secret means a weakness in one mechanism could leak information relevant to the other.
+2. **HMAC key reveals AES key.** If an attacker recovers the 32-byte HMAC key (e.g., through a side-channel attack on the HMAC computation), they automatically obtain the 16-byte AES key as a prefix.
+3. **No key derivation function.** The shared_secret is used directly — no HKDF or similar KDF is applied to derive independent subkeys. This is a departure from cryptographic best practice (cf. RFC 5869).
+
+**Practical impact:** In the current threat model (passive radio capture of LoRa packets), this is unlikely to be directly exploitable — HMAC-SHA256 does not leak its key through normal operation. However, it represents a structural weakness that compounds with any future vulnerability in either the AES or HMAC implementation.
+
+## 8. TXT_MSG (Direct Message) Block Layout
+
+Direct messages use a different plaintext structure (from `BaseChatMesh::composeMsgPacket()`):
+
+```cpp
+memcpy(temp, &timestamp, 4);          // bytes 0-3: timestamp
+temp[4] = (attempt & 3);               // byte 4: attempt counter (0-3)
+memcpy(&temp[5], text, text_len + 1);  // bytes 5+: message text
+// data_len = 5 + text_len (null terminator copied but not counted in length)
+```
+
+**Block layout for TXT_MSG:**
+```
+Block 0: [TS₀][TS₁][TS₂][TS₃][attempt][text bytes 0-10]
+Block 1: [text bytes 11-26] (if message long enough)
+```
+
+Key differences from GRP_TXT:
+- **No sender name in plaintext** — the sender is identified by the source hash in the unencrypted packet header, not in the encrypted payload.
+- **Header is exactly 5 bytes** (4 timestamp + 1 attempt), always. No variable-length field.
+- **11 bytes of message text fit in block 0** (vs. 9 − N for GRP_TXT).
+- **Encrypted with per-pair ECDH shared secret**, not a group PSK. Each sender-recipient pair has a unique key.
+
+**ECB implications for TXT_MSG:**
+- Block 0 is still protected by the timestamp accidental nonce.
+- Blocks 1+ are deterministic, same as GRP_TXT — identical message text at the same offset produces identical ciphertext.
+- However, frequency analysis is harder: each sender-recipient pair uses a different key, so the attacker can only correlate messages within a single pair. The message volume for any given pair is typically much lower than for a group channel.
+- The fixed 5-byte header means block alignment is consistent across ALL direct messages (unlike GRP_TXT where alignment varies by sender name length). An attacker who compromises one ECDH key can build block frequency tables, but only for that specific pair.
+
+## 9. Mitigations
+
+### Priority 1: Switch to AES-128-CTR
+
+Replace ECB with CTR mode. Use the existing 4-byte timestamp + a 4-byte per-message counter as the 8-byte nonce (padded to 16 bytes for the CTR block). Each byte of plaintext gets XORed with a unique keystream byte — eliminates all block-level determinism.
+
+**Wire format change:** None if the nonce is derived from header fields already present. If an explicit counter is added, 4 bytes of overhead per message.
+
+### Priority 2: Derive Independent Subkeys
+
+Apply HKDF (or at minimum, two distinct SHA-256 hashes) to the shared_secret to produce independent AES and HMAC keys. This is a minimal code change:
+```
+aes_key = SHA256(shared_secret || "encrypt")[0..15]
+hmac_key = SHA256(shared_secret || "authenticate")
+```
+
+### Priority 3: Constant-Length Padding
+
+Pad all messages to a fixed block count (e.g., 4 blocks = 64 bytes) to eliminate length leakage. Expensive on LoRa — should be configurable per channel as a security-vs-bandwidth tradeoff.
+
+### Priority 4: Replay Protection
+
+Track seen packet HMACs within a time window. Reject messages with timestamps older than N minutes.
+
+### Priority 5: Channel Key Rotation
+
+Manual or automated periodic rotation of channel PSKs. Even monthly rotation limits the exposure window.
+
+### Priority 6: Forward Secrecy
+
+Ephemeral ECDH for direct messages. Significant protocol change but prevents retroactive decryption on key compromise.
+
+## 10. Speculative: LLM-Assisted Analysis
+
+> **This section is speculation, not formal analysis.** The claims below are plausible but unvalidated. They do not affect the formal findings in §1–9.
+
+An LLM could reduce the sample size needed for block frequency analysis:
+
+1. **Context-aware candidate generation:** Given a sender's known patterns (the sender name is recoverable from block 0's predictable prefix), an LLM could generate likely message continuations and predict which plaintext blocks to look for in the frequency tables.
+2. **Conversational inference:** Timestamps + sender IDs + partially decoded messages could let an LLM reconstruct probable conversation flow, narrowing the search space for unknown blocks.
+3. **Community-specific vocabulary:** Training on public mesh chat logs could yield common phrases and greeting patterns, further reducing the candidate plaintext space.
+
+This does not change the fundamental requirement (blocks 1+ must repeat, or the final block must be in a small enough space for dictionary matching). It potentially reduces the number of captured messages needed for convergence, but no quantitative bound is established.
+
+## 11. Conclusion
+
+MeshCore's encryption has four vulnerabilities, ranked by practical exploitability:
+
+### Vulnerability #1: PSK Brute-Force (Critical)
+
+**No KDF + known-plaintext oracle = offline key recovery from a single packet.** Any channel using a human-memorable passphrase of ≤3 common words or ≤11 alphanumeric characters is recoverable in minutes to hours on commodity GPU hardware. This is the highest-priority threat because it requires minimal attacker capability (one captured packet), succeeds against the most common deployment pattern (human-chosen passphrases), and completely compromises channel confidentiality. See §1.
+
+### Vulnerability #2: ECB Determinism (Medium)
+
+**Blocks beyond the timestamp's reach are deterministic.** Identical plaintext at the same block offset always produces identical ciphertext. For GRP_TXT messages longer than ~9 − N characters (where N is sender name length), this enables frequency analysis on blocks 1+. The partial final block, with its known zero-padding, is the strongest individual target. Exploitation requires hundreds of captured messages with repeated content — a higher bar than PSK brute-force. See §4–§5.
+
+### Vulnerability #3: Key Material Reuse (Medium)
+
+**AES and HMAC share the same key material** without a key derivation function. The AES key is a prefix of the HMAC key. This violates key separation and creates a structural dependency between the encryption and authentication mechanisms. See §7.
+
+### Vulnerability #4: No Forward Secrecy (Low–Medium)
+
+**No forward secrecy, no key rotation, no replay protection.** These are independent of the above but compound the risk: a single key compromise (whether via brute-force or other means) exposes all past and future traffic encrypted under that key. See §9.
+
+**Summary of recommended mitigations (in priority order):**
+1. **(Critical)** Apply a memory-hard KDF (argon2id) to channel PSKs — §1.6
+2. **(Critical)** Add per-channel salt — §1.6
+3. **(High)** Switch from AES-128-ECB to AES-128-CTR — §9
+4. **(High)** Derive independent AES and HMAC subkeys via HKDF — §9
+5. **(Medium)** Constant-length padding, replay protection, key rotation — §9
+6. **(Low)** Forward secrecy via ephemeral ECDH — §9
+
+The timestamp in block 0 was not designed as a nonce and should not be relied upon as one.

docs/proposals/terminal-tui-interface.md

@@ -0,0 +1,132 @@
+# Proposal: Terminal/TUI Interface for CoreScope
+
+**Status:** Approved for MVP
+**Issue:** TBD
+
+## Problem
+
+CoreScope's web UI requires a browser. Operators managing remote mesh deployments often work over SSH — headless servers, Raspberry Pis, field laptops with spotty connectivity. They need to check mesh health, view packet flow, and diagnose issues without opening a browser.
+
+## Vision
+
+A terminal-based user interface (TUI) that connects to a CoreScope instance's API and renders key views directly in the terminal. Think `htop` for mesh networks.
+
+---
+
+## Expert Review
+
+### Carmack (Performance / Data Flow)
+
+- **bubbletea is fine for this.** The TUI is a thin API consumer — it's not processing 7.3M observations locally. The server does the heavy lifting; the TUI just renders summary data from `/api/observers/metrics/summary` (dozens of rows, not millions). No performance concern here.
+- **WebSocket in a TUI — one gotcha:** reconnection. SSH sessions drop, networks flake. The TUI MUST have automatic reconnect with exponential backoff. Don't let a dropped WS kill the whole UI — show a "reconnecting..." status and keep the last-known state visible.
+- **Memory footprint:** Should be trivial. The TUI holds at most a few hundred packets in a ring buffer for the live feed + summary stats. Target <20MB RSS. bubbletea itself is lightweight. The danger is unbounded packet accumulation — use a fixed-size ring buffer (e.g., last 1000 packets) for the live feed, not an ever-growing slice.
+- **Batch WS messages.** Don't re-render on every single packet. Coalesce WS messages and re-render at most 10fps (every 100ms). Terminal rendering is slow — flooding it with updates causes flicker and CPU burn.
+
+### Torvalds (Simplicity / Scope)
+
+- **The scope is too big for an MVP.** Node detail view, sparklines, SSH server mode, multi-instance, export — delete all of that from M1. You need TWO views to prove this works: fleet dashboard table and live packet feed. That's it.
+- **bubbletea vs tview:** bubbletea. Not because Elm-architecture is "clean" — because it's what the Go community actually uses now, the examples are good, and lipgloss makes table rendering trivial. Don't overthink this.
+- **Over-engineering risk is HIGH.** The proposal describes 4 views, stretch features, and SSH server mode before a single line of code exists. Build the two-view demo. Ship it. Then decide what's next based on whether anyone actually uses it.
+- **Same repo, `cmd/tui/`.** Don't create a separate repo for what's going to be 500 lines of Go initially. It shares the same API types. Keep it together.
+- **Kill the "Open Questions" section.** Answer them: Target user = anyone with SSH access. M1 = dashboard + live feed. Same repo. Name = `corescope-tui`. Done. Stop discussing, start building.
+
+### Doshi (Strategy / Prioritization)
+
+- **This is an N (Neutral) feature, not an L.** It doesn't change CoreScope's trajectory — the web UI already works. But it's a solid N: it unlocks a real use case (SSH-only operators) and proves CoreScope's API is a proper platform, not just a web app backend.
+- **The MVP that proves the concept:** Can an operator SSH into a Pi, run `corescope-tui --url http://analyzer:3000`, and immediately see fleet health + live packets? If yes, the concept is proven. Everything else (node detail, sparklines, alerting) is M2+.
+- **Defer list:** Node detail view, RF sparklines, SSH server mode, multi-instance, export, mouse support, true-color fallback, alerting. ALL of these are M2 or later.
+- **Pre-mortem — why would this fail?**
+  1. Nobody uses it because the web UI is good enough (likely for most users — that's fine, this is for the SSH-only niche)
+  2. The API doesn't return what the TUI needs in the right shape (validate this FIRST — curl the endpoints before writing any TUI code)
+  3. Scope creep kills the demo — someone adds "just one more view" and it's never done
+- **Opportunity cost:** Low. This is a day of work for the MVP. The API already exists. The risk is spending a week on polish nobody asked for.
+
+---
+
+## MVP Definition (Demo Target)
+
+**Goal:** A working two-view TUI that connects to any CoreScope instance and displays real-time mesh data in a terminal. Buildable in one focused session.
+
+### View 1: Fleet Dashboard (default)
+```
+┌─ CoreScope TUI ──────────────────────────────────────────┐
+│ Connected: analyzer.00id.net | Observers: 35 | ● Live    │
+├──────────────────────────────────────────────────────────┤
+│ Observer          │ Nodes │ Pkts/hr │ NF     │ Status    │
+│ GY889 Repeater    │   142 │     312 │ -112   │ ● active  │
+│ C0ffee SF         │    89 │     201 │ -108   │ ● active  │
+│ ELC-ONNIE-RPT-1  │    67 │     156 │  -95   │ ▲ warning │
+│ Bar Repeater      │    12 │       3 │  -76   │ ▼ stale   │
+└──────────────────────────────────────────────────────────┘
+  Tab: [Dashboard] [Live Feed]    q: quit    ?: help
+```
+
+- **Data source:** `GET /api/observers/metrics/summary`
+- **Refresh:** Poll every 5s (simple, no WS needed for this view)
+- **Sort:** By observer name initially. Stretch: column sort with arrow keys.
+
+### View 2: Live Packet Feed
+```
+┌─ Live Feed ──────────────────────────────────────────────┐
+│ 14:32:01 ADVERT   GY889 Repeater       → 3 hops  -112dB │
+│ 14:32:02 GRP_TXT  #test "hello world"  → 5 hops   -98dB │
+│ 14:32:03 TXT_MSG  [encrypted]          → 2 hops  -105dB │
+│ 14:32:04 CHAN     #sf "anyone on?"     → 8 hops   -91dB │
+│ ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ │
+└──────────────────────────────────────────────────────────┘
+  Tab: [Dashboard] [Live Feed]    p: pause    q: quit
+```
+
+- **Data source:** WebSocket (`/ws`)
+- **Buffer:** Ring buffer, last 500 packets max
+- **Render:** Coalesce updates, re-render at most 10fps
+- **Reconnect:** Auto-reconnect with exponential backoff (1s, 2s, 4s, max 30s)
+
+### What's NOT in MVP
+- Node detail view
+- RF sparklines
+- SSH server mode (`--serve-ssh`)
+- Multi-instance support
+- Export to CSV/JSON
+- Mouse support
+- Alerting / terminal bell
+- Color theme configuration
+- Custom filters (/ to filter)
+
+### Technical Decisions (Resolved)
+| Question | Answer |
+|---|---|
+| Target user | SSH operators, power users, field techs |
+| Library | bubbletea + lipgloss |
+| Location | `cmd/tui/` in same repo |
+| Binary name | `corescope-tui` |
+| Min terminal | 256-color, 80x24 |
+| State | Stateless — pure API consumer, no local DB |
+
+### Implementation Plan
+1. Scaffold `cmd/tui/main.go` — flag parsing (`--url`), bubbletea app init
+2. Fleet dashboard model — fetch `/api/observers/metrics/summary`, render table
+3. Live feed model — WebSocket connect, ring buffer, packet rendering
+4. Tab switching between views
+5. Status bar (connection state, help hints)
+6. Test against `https://analyzer.00id.net`
+
+---
+
+## Future Milestones (post-MVP, not scheduled)
+
+### M2: Navigation & Detail
+- Node detail view (select observer → see its packets/neighbors)
+- Keyboard navigation (j/k, Enter, Esc)
+- `/` to filter packets
+
+### M3: Visualization
+- RF noise floor sparklines (`▁▂▃▅▇█`)
+- Health history over time
+- Color theme support
+
+### M4: Advanced
+- SSH server mode (`--serve-ssh :2222`)
+- Multi-instance tabs
+- Export current view to stdout (CSV/JSON)
+- Desktop notifications on anomalies

docs/release-notes/v3.5.0.md

@@ -0,0 +1,135 @@
+# CoreScope v3.5.0 🚀
+
+The "stop building from source and start analyzing your mesh" release. 95 commits.
+
+---
+
+## 🐳 Pre-built Docker Images
+
+CoreScope now ships as a ready-to-run Docker image on GitHub Container Registry. No cloning, no building, no dependencies — just pull and run.
+
+```bash
+docker run -d --name corescope -p 80:80 -p 443:443 -p 1883:1883 \
+  -v corescope-data:/app/data \
+  ghcr.io/kpa-clawbot/corescope:v3.5.0
+```
+
+**Using HTTPS with a custom domain?** Mount your Caddyfile and certs directory:
+```bash
+docker run -d --name corescope -p 80:80 -p 443:443 -p 1883:1883 \
+  -v /your/data:/app/data \
+  -v /your/Caddyfile:/etc/caddy/Caddyfile:ro \
+  -v /your/caddy-data:/data/caddy \
+  ghcr.io/kpa-clawbot/corescope:v3.5.0
+```
+Caddy auto-provisions Let's Encrypt certs. Your Caddyfile just needs:
+```
+yourdomain.example.com {
+    reverse_proxy localhost:3000
+}
+```
+
+That's it. Zero config required — MQTT broker, Caddy HTTPS, and SQLite are built in.
+
+**Already running CoreScope?**
+```bash
+# 1. Find your running container name
+docker ps --format '{{.Names}}'
+
+# 2. Stop and remove it
+docker stop <container-name> && docker rm <container-name>
+
+# 3. Pull the pre-built image
+docker pull ghcr.io/kpa-clawbot/corescope:v3.5.0
+
+# 4. Run with your existing data directory
+docker run -d --name corescope -p 80:80 -p 443:443 -p 1883:1883 \
+  -v /your/data:/app/data \
+  -v /your/Caddyfile:/etc/caddy/Caddyfile:ro \
+  -v /your/caddy-data:/data/caddy \
+  ghcr.io/kpa-clawbot/corescope:v3.5.0
+```
+Your data volume stays. Nothing to migrate.
+
+Tags: `v3.5.0` (this release) · `latest` (latest tagged release) · `edge` (master tip, for testing). Env: `DISABLE_CADDY=true` / `DISABLE_MOSQUITTO=true` if you bring your own.
+
+---
+
+## ⚡ 83% Faster
+
+35 performance commits. Packets endpoint p50 dropped from 16.7ms → 2.7ms. Server now serves HTTP within 2 minutes on *any* DB size — async background backfill means you're never staring at a loading screen. N+1 API calls killed everywhere. Prefix map memory cut 10x. WebSocket renders batched via rAF.
+
+---
+
+## 🔬 RF Health Dashboard
+
+New Analytics tab. Per-observer noise floor as color-coded columns (green/yellow/red), airtime utilization, error rates, battery levels. Click any observer for the full breakdown. Region-filterable. This is the beginning of making CoreScope more than just a packet viewer.
+
+---
+
+## 🗺️ See Where Traces Actually Go
+
+Send a trace → watch it on the live map. Solid animated line shows how far it got. Dashed ghost shows where it didn't reach. Finally know *where* your trace failed, not just *that* it failed.
+
+---
+
+## 📊 Things That Were Lying To You
+
+- "By Repeaters" was counting companions. Fixed.
+- Zero-hop adverts claimed "1 byte hash" when the hash size was unknowable. Fixed.
+- "Packets through this node" showed packets through a *different* node with the same prefix. Fixed — now uses the neighbor affinity graph.
+- Table sorting on nodes/neighbors/observers silently did nothing. Fixed.
+
+---
+
+## 🔗 Deep Links · 🎨 Channel Colors · 📱 Mobile · 🔑 Security
+
+**Deep links** — every page state goes in the URL. Share a link to a specific node, filter, or analytics tab.
+
+**Channel colors** — click the color dot next to any channel, pick from 8 colors, see it highlighted across the feed. Persists in localStorage.
+
+**Distance units** — km, miles, or auto-detect from locale. Customizer → Display.
+
+**Mobile** — 44px touch targets, ARIA labels, responsive breakpoints.
+
+**Security** — weak API keys rejected at startup. License: GPL v3.
+
+---
+
+## 📡 Full API Documentation
+
+Every endpoint is now documented with an auto-generated OpenAPI 3.0 spec — always in sync with the running server.
+
+- **Interactive Swagger UI:** [analyzer.00id.net/api/docs](https://analyzer.00id.net/api/docs) — browse and test all 40+ endpoints
+- **Machine-readable spec:** [analyzer.00id.net/api/spec](https://analyzer.00id.net/api/spec) — import into Postman, Insomnia, or use for bot/integration development
+
+On your own instance: `/api/docs` and `/api/spec`.
+
+---
+
+## 🐛 14 Bugs Squashed
+
+Live map crash, zero-hop hash lies, animation freezes, repeater miscounts, prefix collisions, dead channel picker, invisible buttons, broken sorting, memory leak, and more.
+
+---
+
+## Upgrade
+
+```bash
+docker stop <container-name> && docker rm <container-name>
+docker pull ghcr.io/kpa-clawbot/corescope:v3.5.0
+
+# HTTP only:
+docker run -d --name corescope -p 80:80 -p 1883:1883 \
+  -v /your/data:/app/data \
+  ghcr.io/kpa-clawbot/corescope:v3.5.0
+
+# With HTTPS (custom domain):
+docker run -d --name corescope -p 80:80 -p 443:443 -p 1883:1883 \
+  -v /your/data:/app/data \
+  -v /your/Caddyfile:/etc/caddy/Caddyfile:ro \
+  -v /your/caddy-data:/data/caddy \
+  ghcr.io/kpa-clawbot/corescope:v3.5.0
+```
+
+First start backfills `resolved_path` in the background. No downtime. No breaking changes.

docs/specs/channel-color-highlighting.md

@@ -0,0 +1,148 @@
+# Channel Color Highlighting Spec
+
+**Status:** Proposed  
+**Issue:** [#271](https://github.com/Kpa-clawbot/CoreScope/issues/271)  
+**Author:** Stinkmeaner (AI)  
+**Date:** 2026-04-05
+
+## Problem
+
+When monitoring multiple active hash channels simultaneously on the Live tab, all `GRP_TXT` traffic renders identically — same color, same styling. Users tracking specific channels (e.g. `#wardriving`) cannot visually distinguish their traffic from other channel activity without reading each row's channel field.
+
+## Solution
+
+Allow users to assign custom highlight colors to specific hash channels. Colors propagate across the Live feed, map animations, and timeline. Unassigned channels retain the default `GRP_TXT` styling.
+
+### Data Model
+
+**Storage:** Single `localStorage` key `live-channel-colors`
+
+```json
+{
+  "#wardriving": "#ef4444",
+  "#meshnet": "#3b82f6"
+}
+```
+
+- Keyed by resolved channel name (e.g. `#wardriving`) or raw hash prefix if unresolved
+- Included in customizer theme export/import for portability
+- Maximum ~16 assignments (no hard limit, but UI should discourage excess — see Edge Cases)
+
+### Channel Matching
+
+- Match on the packet's `channel` or `group` field
+- Handle both resolved channel names and raw hash prefixes
+- Only applies to `GRP_TXT` packet types — other types retain their existing `TYPE_COLORS` styling
+
+### Visual Treatment
+
+**Feed rows (primary):**
+- 4px colored left border
+- Subtle background tint: channel color at 8–10% opacity
+- Text color unchanged — contrast must remain accessible
+
+**Map animations:**
+- Packet arcs use the assigned channel color instead of default `TYPE_COLORS.GRP_TXT`
+- Node markers retain role-based coloring (channel color does NOT override node markers)
+
+**Timeline sparkline:**
+- Dots/bars colored per channel assignment
+- Unassigned channels use default color
+
+**Auto-legend:**
+- Generated from active assignments
+- Displayed near the feed header
+- Color swatch + channel name, compact horizontal layout
+
+### Configuration UI
+
+**Quick assign (primary workflow):**
+- Right-click (long-press on mobile) a channel name in the Live feed
+- Color picker popover with ~12 preset swatches + custom hex input
+- "Clear" button to remove assignment
+
+**Customizer panel (management):**
+- New "Channel Colors" section under existing "Packet Type Colors"
+- Lists all assigned channels with color swatches
+- Add/edit/remove individual assignments
+- "Clear All" button
+- Synced with theme export/import
+
+### Priority Rules
+
+| Context | Color source |
+|---------|-------------|
+| Feed row background/border | Channel color (if assigned), else default |
+| Feed row text | Always default (no override) |
+| Map packet arcs | Channel color (if assigned), else `TYPE_COLORS.GRP_TXT` |
+| Map node markers | Always role color (no override) |
+| Timeline dots | Channel color (if assigned), else default |
+
+## Edge Cases
+
+- **10+ colors:** At ~10 simultaneous assignments, colors become hard to distinguish. The UI should show a soft warning ("Many colors assigned — consider clearing unused ones") but not block the user.
+- **Color conflicts with role/type colors:** Channel color takes priority for feed row highlighting only. Role colors remain authoritative for node markers.
+- **Removal:** Clearing a channel color reverts to default styling immediately — no page refresh needed.
+- **Non-GRP_TXT packets:** Channel color never applied. These packets have no channel association.
+- **Customizer rework (#288):** If the customizer rework lands first, the Channel Colors section should follow the new single-delta-object pattern (`cs-theme-overrides`). If it hasn't landed, use the standalone `live-channel-colors` key and migrate later.
+- **Dark/light mode:** Channel colors are mode-independent (same color in both modes). The 8–10% opacity tint ensures readability in both themes.
+
+## Milestones
+
+### M1: Core model + feed row highlighting
+- `localStorage` read/write for `live-channel-colors`
+- Feed row rendering: left border + background tint
+- Unit tests for storage CRUD and color application logic
+
+### M2: Quick-assign UI
+- Right-click / long-press context menu on channel names
+- Color picker popover with presets + custom hex
+- Clear button
+- Playwright E2E test for assign/clear workflow
+
+### M3: Map animation integration
+- Packet arc color lookup from channel assignments
+- Falls back to `TYPE_COLORS.GRP_TXT` when unassigned
+- Visual verification via browser screenshot
+
+### M4: Customizer section + export/import
+- "Channel Colors" management panel in customizer
+- Include channel colors in theme export JSON
+- Import restores channel colors
+- Unit tests for export/import round-trip
+
+### M5: Timeline coloring + auto-legend
+- Timeline sparkline uses channel colors
+- Auto-legend renders near feed header
+- Playwright E2E for legend visibility
+
+## Testing
+
+| Level | What | How |
+|-------|------|-----|
+| Unit | Storage CRUD, color lookup, merge with defaults | `test-frontend-helpers.js` via `vm.createContext` |
+| Unit | Export/import round-trip with channel colors | Same |
+| E2E | Quick-assign popover, color applied to feed rows | Playwright against localhost |
+| E2E | Customizer channel colors section | Playwright |
+| E2E | Legend appears when ≥1 channel colored | Playwright |
+| Visual | Map arcs colored, dark/light mode readability | Browser screenshot |
+
+## Expert Review Notes
+
+### Tufte (Visualization)
+- **Left border + tint is sound.** The 4px border is data-ink (encodes channel identity). The tint at 8–10% opacity provides grouping without overwhelming the data. This is information encoding, not decoration.
+- **Risk at scale:** Beyond ~8 colors, perceptual distinguishability drops sharply. The spec correctly warns but doesn't enforce. Consider using a curated palette of maximally-distinct colors (like ColorBrewer qualitative sets) as the preset swatches rather than a free-form picker.
+- **Auto-legend is correct:** Direct labeling on every row would be redundant (channel name already in the row). A compact legend near the feed is the right balance — it teaches the encoding once.
+- **No chartjunk introduced.** The visual treatment adds information (channel identity) without decorative excess.
+
+### Torvalds (Code Quality)
+- **localStorage is fine** for user preferences with <1KB payloads. No need for IndexedDB or server-side storage.
+- **5 milestones is appropriate.** Each is independently shippable and testable. No milestone depends on speculation about future milestones.
+- **Watch the customizer coupling.** If #288 lands, the `live-channel-colors` key should merge into `cs-theme-overrides`. Design the read/write functions to abstract the storage key so migration is a one-line change, not a rewrite.
+- **Keep the color picker simple.** Don't build a custom color picker — use `<input type="color">` with preset swatch buttons. The browser's native picker is fine.
+
+### Doshi (Product Strategy)
+- **This is N (Neutral).** It's a genuine usability improvement for multi-channel monitoring, but it doesn't change CoreScope's trajectory. It won't attract new users or unlock new use cases — it makes existing power users slightly more efficient.
+- **Opportunity cost is low.** Each milestone is small (~1-2 hours of work). The total investment is modest.
+- **5 milestones is fine** given each is small. Shipping M1+M2 alone delivers 80% of the value. M3–M5 are polish. Consider M1+M2 as the MVP gate — if nobody uses channel colors after M2, stop there.
+- **Pre-mortem:** This fails if users rarely monitor 2+ channels simultaneously, making the problem theoretical. Validate that multi-channel monitoring is a real workflow before M3.

docs/specs/customizer-rework.md

@@ -0,0 +1,568 @@
+# Customizer Rework Spec
+
+## Overview
+
+The current customizer (`public/customize.js`) suffers from fundamental state management issues documented in [issue #284](https://github.com/Kpa-clawbot/CoreScope/issues/284). State is scattered across 7 localStorage keys, CSS updates bypass the data layer, and there's no single source of truth for the effective configuration.
+
+This spec defines a clean rework based on event-driven state management with a single data flow path. The goal: predictable state, minimal storage footprint, portable config format, and zero ambiguity about which values are active and why.
+
+## Design Decisions
+
+These are agreed and final. Do not reinterpret or deviate.
+
+1. **Three state layers:** server defaults (immutable after fetch), user overrides (delta in localStorage), effective config (computed via merge, never stored directly).
+2. **Single data flow:** user action → debounce (~300ms) → write delta to localStorage → read back from localStorage → merge with server defaults → apply CSS variables. No shortcuts, no optimistic CSS updates (see Decision #12 for the one exception).
+3. **One localStorage key:** `cs-theme-overrides` — replaces the current 7 scattered keys (`meshcore-user-theme`, `meshcore-timestamp-mode`, `meshcore-timestamp-timezone`, `meshcore-timestamp-format`, `meshcore-timestamp-custom-format`, `meshcore-heatmap-opacity`, `meshcore-live-heatmap-opacity`).
+4. **Universal format:** same shape as the server's `ThemeResponse` plus additional keys. Works identically for user export, admin `theme.json`, and user import.
+5. **User overrides always win** in merge — `merge(serverDefaults, userOverrides)` = effective config.
+6. **Override indicator:** shown in customizer panel ONLY when override value differs from current server default.
+7. **No silent pruning:** overrides stay in localStorage until the user explicitly resets them (per-field reset or full reset). The delta may contain values that happen to match current server defaults — that's fine. User intent is preserved; nothing silently disappears.
+8. **Per-field reset:** remove a single key from the delta → re-merge → re-apply CSS.
+9. **Full reset:** `localStorage.removeItem('cs-theme-overrides')` → re-merge (effective = server defaults) → re-apply CSS.
+10. **Export = dump delta object as JSON download. Import = validate shape, write to localStorage, trigger re-merge.**
+11. **No CSS magic:** CSS variables ONLY update after the localStorage round-trip completes. No optimistic updates (see Decision #12 for the one exception).
+12. **Color picker optimistic CSS exception:** For continuous inputs (color pickers, sliders), CSS is updated optimistically during `input` events for visual responsiveness. The localStorage write only happens on `change` event (mouseup/blur). On `change`, the full pipeline runs: write → read → merge → apply (which will match the optimistic state). If the user refreshes mid-drag before `change` fires, the change is lost — this is acceptable. This is the ONLY exception to the localStorage-first rule.
+
+## Dark/Light Mode
+
+The customizer treats light and dark mode as separate override sections:
+
+- **`theme`** stores light mode color overrides.
+- **`themeDark`** stores dark mode color overrides.
+- When the user changes a color in the customizer, it writes to whichever section matches their current mode: `theme` if light, `themeDark` if dark.
+- The dark/light mode toggle preference (`meshcore-theme` localStorage key) is **separate** from the delta object. It is a view preference, not a customization — it is not stored in `cs-theme-overrides`.
+- The customizer UI shows color fields for the currently active mode only. Switching modes re-renders the color fields with values from the matching section.
+
+## Presets
+
+The existing preset themes are preserved and flow through the standard pipeline:
+
+**Available presets:** Default, Ocean, Forest, Sunset, Monochrome.
+
+**How presets work:**
+- Clicking a preset writes its values to localStorage via the same pipeline as any other change: preset data → `writeOverrides()` → read back → merge → apply CSS.
+- Presets are NOT special — they are pre-built delta objects applied through the standard flow.
+- Each preset contains both `theme` (light) and `themeDark` (dark) sections, plus any other overrides the preset defines (e.g., `nodeColors`).
+- **"Reset to Default"** = clear all overrides (equivalent to full reset: `localStorage.removeItem('cs-theme-overrides')` → re-merge → apply).
+
+**Preset data format:** Same shape as the delta object. Example:
+
+```json
+{
+  "theme": {
+    "accent": "#0077b6",
+    "navBg": "#03045e",
+    "background": "#f0f7fa"
+  },
+  "themeDark": {
+    "accent": "#48cae4",
+    "navBg": "#03045e",
+    "background": "#0a1929"
+  }
+}
+```
+
+Applying a preset **replaces** the entire delta (it's a `writeOverrides(presetData)`, not a merge onto existing overrides). The user can then further customize individual fields on top.
+
+## Data Model
+
+### Delta Object Format
+
+The user override delta is a sparse object — it only contains fields the user has explicitly changed. The shape mirrors the server's `ThemeResponse` (from `/api/config/theme`) plus additional client-only sections:
+
+```json
+{
+  "branding": {
+    "siteName": "string — site name override",
+    "tagline": "string — tagline override",
+    "logoUrl": "string — custom logo URL",
+    "faviconUrl": "string — custom favicon URL"
+  },
+  "theme": {
+    "accent": "string — CSS color, light mode accent",
+    "accentHover": "string — CSS color, light mode accent hover",
+    "navBg": "string — CSS color, nav background",
+    "navBg2": "string — CSS color, nav secondary background",
+    "navText": "string — CSS color, nav text",
+    "navTextMuted": "string — CSS color, nav muted text",
+    "background": "string — CSS color, page background",
+    "text": "string — CSS color, body text",
+    "textMuted": "string — CSS color, muted text",
+    "border": "string — CSS color, borders",
+    "surface1": "string — CSS color, surface level 1",
+    "surface2": "string — CSS color, surface level 2",
+    "cardBg": "string — CSS color, card backgrounds",
+    "contentBg": "string — CSS color, content area background",
+    "detailBg": "string — CSS color, detail pane background",
+    "inputBg": "string — CSS color, input backgrounds",
+    "rowStripe": "string — CSS color, alternating row stripe",
+    "rowHover": "string — CSS color, row hover highlight",
+    "selectedBg": "string — CSS color, selected row background",
+    "statusGreen": "string — CSS color, healthy status",
+    "statusYellow": "string — CSS color, degraded status",
+    "statusRed": "string — CSS color, critical status",
+    "font": "string — CSS font-family for body text",
+    "mono": "string — CSS font-family for monospace"
+  },
+  "themeDark": {
+    "/* same keys as theme — dark mode overrides */"
+  },
+  "nodeColors": {
+    "repeater": "string — CSS color",
+    "companion": "string — CSS color",
+    "room": "string — CSS color",
+    "sensor": "string — CSS color",
+    "observer": "string — CSS color"
+  },
+  "typeColors": {
+    "ADVERT": "string — CSS color",
+    "GRP_TXT": "string — CSS color",
+    "TXT_MSG": "string — CSS color",
+    "ACK": "string — CSS color",
+    "REQUEST": "string — CSS color",
+    "RESPONSE": "string — CSS color",
+    "TRACE": "string — CSS color",
+    "PATH": "string — CSS color",
+    "ANON_REQ": "string — CSS color"
+  },
+  "home": {
+    "heroTitle": "string",
+    "heroSubtitle": "string",
+    "steps": "[array of {emoji, title, description}]",
+    "checklist": "[array of strings]",
+    "footerLinks": "[array of {label, url}]"
+  },
+  "timestamps": {
+    "defaultMode": "string — 'ago' | 'absolute'",
+    "timezone": "string — 'local' | 'utc'",
+    "formatPreset": "string — 'iso' | 'iso-seconds' | 'locale'",
+    "customFormat": "string — custom strftime-style format"
+  },
+  "heatmapOpacity": "number — 0.0 to 1.0",
+  "liveHeatmapOpacity": "number — 0.0 to 1.0"
+}
+```
+
+**Rules:**
+- All sections and keys are optional. An empty object `{}` means "no overrides."
+- The `timestamps`, `heatmapOpacity`, and `liveHeatmapOpacity` keys are client-only extensions — not part of the server's `ThemeResponse`, but included in the universal format for portability.
+
+### localStorage Key
+
+**Key:** `cs-theme-overrides`
+**Value:** JSON string of the delta object above.
+**Absent key** = no overrides = effective config equals server defaults.
+
+### Dark/Light Mode Preference
+
+**Key:** `meshcore-theme`
+**Value:** `"dark"` or `"light"` (or absent = follow system preference).
+**This key is NOT part of the delta object.** It controls which mode is active, not which colors are used. The delta stores overrides for both modes independently in `theme` and `themeDark`.
+
+## Data Flow Diagrams
+
+### Page Load
+
+```
+┌─────────────┐     ┌──────────────────┐     ┌─────────────────┐
+│ Fetch        │     │ Read localStorage │     │ Migration check │
+│ /api/config/ │     │ cs-theme-overrides│     │ (one-time)      │
+│ theme        │     └────────┬─────────┘     └────────┬────────┘
+└──────┬──────┘              │                         │
+       │                     │    ┌────────────────────┘
+       ▼                     ▼    ▼
+  serverDefaults      userOverrides (possibly migrated)
+       │                     │
+       ▼                     ▼
+  ┌──────────────────────────────────────┐
+  │ computeEffective(server, userOverrides) │
+  └──────────────┬───────────────────────┘
+                 │
+                 ▼
+  ┌──────────────────────────────────────┐
+  │ window.SITE_CONFIG = effective       │ ← atomic assignment
+  └──────────────┬───────────────────────┘
+                 │
+                 ▼
+  ┌──────────────────────┐
+  │ applyCSS(effective)  │ ← sets CSS vars on :root for current mode
+  └──────────────────────┘
+                 │
+                 ▼
+  ┌──────────────────────────────┐
+  │ dispatch 'theme-changed'     │ ← bare signal, no payload
+  └──────────────────────────────┘
+```
+
+### User Change (e.g., picks new accent color)
+
+```
+  User action (input/click)
+       │
+       ▼
+  debounce(300ms)
+       │
+       ▼
+  setOverride('theme', 'accent', '#ff0000')
+       │
+       ├─► readOverrides()          ← read current delta from localStorage
+       │       │
+       │       ▼
+       ├─► update delta object      ← set delta.theme.accent = '#ff0000'
+       │       │
+       │       ▼
+       ├─► writeOverrides(delta)    ← serialize & write to localStorage
+       │       │
+       │       ▼
+       ├─► readOverrides()          ← read BACK from localStorage (round-trip)
+       │       │
+       │       ▼
+       ├─► computeEffective(server, delta)
+       │       │
+       │       ▼
+       ├─► window.SITE_CONFIG = effective  ← atomic assignment
+       │       │
+       │       ▼
+       └─► applyCSS(effective)      ← CSS vars updated on :root
+              │
+              ▼
+         dispatch 'theme-changed'
+```
+
+**Color picker / slider exception:** During continuous `input` events (drag), CSS is updated optimistically (directly setting `--var` on `:root`) without the localStorage round-trip. The full pipeline above only runs on the `change` event (mouseup/blur).
+
+### Per-Field Reset
+
+```
+  User clicks reset icon on a field
+       │
+       ▼
+  clearOverride('theme', 'accent')
+       │
+       ├─► readOverrides()
+       ├─► delete delta.theme.accent
+       ├─► if delta.theme is empty, delete delta.theme
+       ├─► writeOverrides(delta)
+       ├─► readOverrides()          ← round-trip
+       ├─► computeEffective(server, delta)
+       ├─► window.SITE_CONFIG = effective
+       └─► applyCSS(effective)
+              │
+              ▼
+         dispatch 'theme-changed'
+```
+
+### Full Reset
+
+```
+  User clicks "Reset All"
+       │
+       ▼
+  localStorage.removeItem('cs-theme-overrides')
+       │
+       ▼
+  computeEffective(server, {})    ← no overrides = server defaults
+       │
+       ▼
+  window.SITE_CONFIG = effective
+       │
+       ▼
+  applyCSS(effective)
+       │
+       ▼
+  dispatch 'theme-changed'
+```
+
+### Export
+
+```
+  User clicks "Export"
+       │
+       ▼
+  readOverrides()
+       │
+       ▼
+  JSON.stringify(delta, null, 2)
+       │
+       ▼
+  trigger download as .json file
+```
+
+### Import
+
+```
+  User selects .json file
+       │
+       ▼
+  parse JSON
+       │
+       ▼
+  validateShape(parsed)           ← check structure, validate values
+       │
+       ├─► invalid → show error, abort
+       │
+       ▼ valid
+  writeOverrides(parsed)
+       │
+       ▼
+  readOverrides()                 ← round-trip
+       │
+       ▼
+  computeEffective(server, delta)
+       │
+       ▼
+  window.SITE_CONFIG = effective
+       │
+       ▼
+  applyCSS(effective)
+       │
+       ▼
+  dispatch 'theme-changed'
+```
+
+## Function Signatures
+
+### `readOverrides() → object`
+
+Reads `cs-theme-overrides` from localStorage, parses as JSON. Returns empty object `{}` on missing key, parse error, or non-object value. Never throws.
+
+### `writeOverrides(delta: object) → void`
+
+Serializes `delta` to JSON and writes to `cs-theme-overrides` in localStorage. If `delta` is empty (`{}`), removes the key entirely.
+
+**Validation on write:**
+- Color values must match: `#hex` (3, 4, 6, or 8 digit), `rgb()`, `rgba()`, `hsl()`, `hsla()`, or CSS named colors. Invalid color values are rejected (not written) with `console.warn`.
+- Numeric values (`heatmapOpacity`, `liveHeatmapOpacity`) must be finite numbers in the range 0–1. Invalid values are rejected with `console.warn`.
+- Timestamp enum values are validated against known options (`defaultMode`: `'ago'`/`'absolute'`; `timezone`: `'local'`/`'utc'`; `formatPreset`: `'iso'`/`'iso-seconds'`/`'locale'`). Invalid values are rejected with `console.warn`.
+
+**Quota error handling:**
+- Wrap `localStorage.setItem` in try/catch.
+- On `QuotaExceededError`: show a visible warning to the user ("Storage full — changes may not be saved"), log to console.
+- Do NOT silently swallow the error.
+
+### `computeEffective(serverConfig: object, userOverrides: object) → object`
+
+Deep merges `userOverrides` onto `serverConfig`. For each section (e.g., `theme`, `nodeColors`), if `userOverrides` has the section, its keys override the corresponding `serverConfig` keys. Top-level non-object keys (e.g., `heatmapOpacity`) are directly overridden.
+
+Returns a new object — neither input is mutated.
+
+**Merge rules:**
+- Object sections: shallow merge per section (`Object.assign({}, server.theme, user.theme)`)
+- Array sections (e.g., `home.steps`): full replacement (user array wins entirely, no element-level merge)
+- Scalar sections (e.g., `heatmapOpacity`): direct replacement
+
+After computing the effective config, writes it to `window.SITE_CONFIG` atomically (single assignment, not piecemeal mutations).
+
+### `applyCSS(effectiveConfig: object) → void`
+
+Maps effective config values to CSS custom properties on `:root`. Behavior:
+
+1. Reads the current mode (light/dark) from the `meshcore-theme` localStorage key, falling back to system preference (`prefers-color-scheme`).
+2. Applies the matching section's values: `theme` for light mode, `themeDark` for dark mode.
+3. Also applies mode-independent values: node colors as `--node-{role}`, type colors as `--type-{name}`, font families as `--font-body` and `--font-mono`.
+4. Does NOT generate dual CSS rule blocks — only the current mode's values are applied to `:root`.
+5. On dark/light mode toggle, `applyCSS` is called again to re-apply the correct section.
+
+Updates the `<style>` element (create if absent, reuse if present). Dispatches a `theme-changed` CustomEvent on `window` after applying.
+
+### `theme-changed` Event
+
+- `theme-changed` is a bare `CustomEvent` with no payload (matches current behavior).
+- After each merge cycle, the effective config is written to `window.SITE_CONFIG` atomically (single assignment).
+- `window.SITE_CONFIG` is the canonical readable source for effective config throughout the app. All existing listeners that read from `SITE_CONFIG` continue to work without changes.
+
+### `setOverride(section: string, key: string, value: any) → void`
+
+Sets a single override. For nested sections (e.g., `section='theme'`, `key='accent'`), sets `delta[section][key] = value`. For top-level scalars (e.g., `section=null`, `key='heatmapOpacity'`), sets `delta[key] = value`.
+
+Follows the full data flow: read → update → write → read-back → merge → apply CSS → dispatch `theme-changed`. Debounced at ~300ms (the debounce wraps the write-through-to-CSS portion).
+
+### `clearOverride(section: string, key: string) → void`
+
+Removes a single key from the delta. If the section becomes empty after removal, removes the section too. Triggers the full data flow (no debounce — resets should feel instant).
+
+### `migrateOldKeys() → object | null`
+
+One-time migration. Checks for any of the 7 legacy localStorage keys. If found:
+1. Reads all legacy values
+2. Maps them into the new delta format (see Migration Plan)
+3. Writes the merged delta to `cs-theme-overrides`
+4. Removes all 7 legacy keys
+5. Returns the migrated delta
+
+Returns `null` if no legacy keys found.
+
+### `validateShape(obj: any) → { valid: boolean, errors: string[] }`
+
+Validates that an imported object conforms to the expected shape:
+- Must be a plain object
+- Top-level keys must be from the known set: `branding`, `theme`, `themeDark`, `nodeColors`, `typeColors`, `home`, `timestamps`, `heatmapOpacity`, `liveHeatmapOpacity`
+- Section values must be objects (where expected) or correct scalar types
+- Color values are validated: must match `#hex` (3, 4, 6, or 8 digit), `rgb()`, `rgba()`, `hsl()`, `hsla()`, or CSS named colors
+- Numeric values (`heatmapOpacity`, `liveHeatmapOpacity`) must be finite numbers in range 0–1
+- Timestamp enum values validated against known options
+
+Unknown top-level keys cause a warning but don't fail validation (forward compatibility).
+
+## Migration Plan
+
+On first page load, before the normal init flow:
+
+1. Check if `cs-theme-overrides` already exists → if yes, skip migration.
+2. Check if ANY of the 7 legacy keys exist in localStorage.
+3. If legacy keys found, build a delta object using the exact mapping below:
+
+### Field-by-Field Migration Mapping
+
+```
+meshcore-user-theme (JSON) → parse, map directly:
+  .branding  → delta.branding
+  .theme     → delta.theme
+  .themeDark → delta.themeDark
+  .nodeColors → delta.nodeColors
+  .typeColors → delta.typeColors
+  .home      → delta.home
+  (any other keys are dropped)
+
+meshcore-timestamp-mode           → delta.timestamps.defaultMode
+meshcore-timestamp-timezone       → delta.timestamps.timezone
+meshcore-timestamp-format         → delta.timestamps.formatPreset
+meshcore-timestamp-custom-format  → delta.timestamps.customFormat
+meshcore-heatmap-opacity          → delta.heatmapOpacity (parseFloat)
+meshcore-live-heatmap-opacity     → delta.liveHeatmapOpacity (parseFloat)
+```
+
+4. Write the assembled delta to `cs-theme-overrides`.
+5. Delete all 7 legacy keys.
+6. Continue with normal init.
+
+**Edge cases:**
+- If `meshcore-user-theme` contains invalid JSON, skip it (log a warning to console).
+- If a legacy value is empty string or null, skip that field.
+- Migration runs exactly once — the presence of `cs-theme-overrides` (even as `{}`) prevents re-migration.
+
+## `allowCustomFormat` — User Preferences Trump
+
+The server-side `allowCustomFormat` gate is not enforced client-side. If a user imports a delta with a custom format, it's applied regardless. The server controls what formats are available in the UI (whether the custom format input field is shown), but does not block stored preferences.
+
+## Override Indicator UX
+
+In the customizer panel, each field that has an active override (value differs from server default) shows a visual indicator:
+
+- **Indicator:** A small dot or icon (e.g., `●` or a reset arrow `↺`) adjacent to the field label.
+- **Color:** Use the accent color to draw attention without being noisy.
+- **Behavior:** Clicking the indicator resets that single field (calls `clearOverride`).
+- **Tooltip:** "Reset to server default" or "This value differs from the server default."
+- **Absence:** Fields matching the server default show no indicator — clean and minimal.
+
+**Section-level indicator:** If any field in a section (e.g., "Theme Colors") is overridden, the tab/section header shows a count badge (e.g., "Theme Colors (3)").
+
+**"Reset All" button:** Always visible at bottom of panel. Confirms before executing (`localStorage.removeItem` + re-merge).
+
+## UX Requirements
+
+### Browser-Local Banner
+
+The customizer panel must display a persistent, always-visible notice:
+
+> **"These settings are saved in your browser only and don't affect other users."**
+
+This is NOT a tooltip, NOT a dismissible popup — it must be always visible in the panel header or footer area. Users must understand at a glance that their changes are local.
+
+### Auto-Save Indicator
+
+Show a persistent status in the customizer panel footer, Google Docs style — subtle but always present:
+
+- **Default state:** "All changes saved" (muted text)
+- **During debounce:** "Saving..." (muted text)
+- **On quota error:** "⚠️ Storage full — changes may not be saved" (red text, persistent until resolved)
+
+The indicator reflects the actual state of the localStorage write, not just the UI action.
+
+## Server Compatibility
+
+The delta format is intentionally shaped to be a valid subset of the server's `theme.json` admin config file. This means:
+
+- **User export → admin import:** An admin can take a user's exported JSON and drop it into `theme.json` as server defaults. The `timestamps`, `heatmapOpacity`, and `liveHeatmapOpacity` keys are ignored by the current server (it doesn't read them from `theme.json`), but they don't cause errors.
+- **Admin config → user import:** A `theme.json` file can be imported as user overrides. Unknown server-only keys are ignored by the client.
+- **Round-trip safe:** Export → import produces identical delta (assuming no server default changes between operations).
+
+The server's `ThemeResponse` struct currently returns: `branding`, `theme`, `themeDark`, `nodeColors`, `typeColors`, `home`. The client-only extensions (`timestamps`, `heatmapOpacity`, `liveHeatmapOpacity`) are additive — they extend the format without conflicting.
+
+## Testing Requirements
+
+### Unit Tests (Node.js, no browser required)
+
+1. **`readOverrides`**
+   - Returns `{}` when key is absent
+   - Returns `{}` when key contains invalid JSON
+   - Returns `{}` when key contains a non-object (string, array, number)
+   - Returns parsed object when key contains valid JSON object
+
+2. **`writeOverrides`**
+   - Writes serialized JSON to localStorage
+   - Removes key when delta is empty `{}`
+   - Round-trips correctly (write → read = identical object)
+   - Rejects invalid color values with console.warn
+   - Rejects out-of-range numeric values with console.warn
+   - Rejects invalid timestamp enum values with console.warn
+   - Handles QuotaExceededError gracefully (warns user, does not throw)
+
+3. **`computeEffective`**
+   - Returns server defaults when overrides is `{}`
+   - Overrides a single key in a section
+   - Overrides multiple keys across sections
+   - Does not mutate either input
+   - Handles missing sections in overrides gracefully
+   - Array values (e.g., `home.steps`) are fully replaced, not merged
+   - Top-level scalars (`heatmapOpacity`) are directly replaced
+
+4. **`setOverride` / `clearOverride`**
+   - Setting a value stores it in the delta
+   - Clearing a key removes it from delta
+   - Clearing the last key in a section removes the section
+   - Full data flow executes (CSS vars updated)
+
+5. **`migrateOldKeys`**
+   - Migrates all 7 keys correctly using exact field mapping
+   - Handles partial migration (only some keys present)
+   - Handles invalid JSON in `meshcore-user-theme`
+   - Removes all legacy keys after migration
+   - Skips migration if `cs-theme-overrides` already exists
+   - Returns null when no legacy keys found
+   - Drops unknown keys from `meshcore-user-theme`
+
+6. **`validateShape`**
+   - Accepts valid delta objects
+   - Accepts empty object
+   - Rejects non-objects (string, array, null)
+   - Warns on unknown top-level keys (doesn't reject)
+   - Validates section types (object vs scalar)
+   - Rejects invalid color values
+   - Rejects out-of-range opacity values
+   - Rejects invalid timestamp enum values
+
+### Browser/E2E Tests (Playwright)
+
+1. **Customizer opens and shows current values** — fields reflect effective config.
+2. **Changing a color updates CSS variable** — after debounce, `:root` has new value.
+3. **Override indicator appears** when value differs from server default.
+4. **Per-field reset** removes override, reverts to server default, indicator disappears.
+5. **Full reset** clears all overrides, all fields show server defaults.
+6. **Export** downloads a JSON file with current delta.
+7. **Import** applies overrides from uploaded JSON file.
+8. **Migration** — set legacy keys, reload, verify they're migrated and removed.
+9. **Preset application** — clicking a preset applies its colors, fields update.
+10. **Dark/light mode toggle** — switching mode re-applies correct section's CSS vars.
+11. **Browser-local banner** — verify persistent notice is visible in customizer panel.
+12. **Auto-save indicator** — verify status text updates during and after changes.
+
+## What's NOT In Scope
+
+- **Undo/redo stack** — could be added as P2. For v1, per-field reset to server default is the only revert mechanism.
+- **Cross-tab synchronization** — two tabs editing simultaneously may clobber each other's changes. Acceptable for v1.
+- **Server-side timestamp config** (`allowCustomFormat` gate) — remains server-only, not exposed in the customizer delta. The server controls UI availability but does not block stored preferences (see `allowCustomFormat` section above).
+- **Admin import endpoint** — no server API for uploading `theme.json` via the UI. Admins edit the file directly. Future work.
+- **Map config overrides** (`mapDefaults.center`, `mapDefaults.zoom`) — separate concern, not part of theme. Future work.
+- **Geo-filter config** — server-only. Not in scope.
+- **Per-page layout preferences** (column widths, sort orders) — separate from theming. Future work.

docs/specs/deployment-simplification.md

@@ -0,0 +1,311 @@
+# Deployment Simplification Spec
+
+**Status:** Draft  
+**Author:** Kpa-clawbot  
+**Date:** 2026-04-05  
+
+## Current State
+
+CoreScope deployment today requires:
+
+1. **Clone the repo** and build from source (`docker compose build`)
+2. **Create a config.json** — the example is 100+ lines with MQTT credentials, channel keys, theme colors, regions, cache TTLs, health thresholds, branding, and more. An operator must understand all of this before seeing a single packet.
+3. **Set up a Caddyfile** for TLS (separate `caddy-config/` directory, bind-mounted)
+4. **Understand the supervisord architecture** — the container runs 4 processes (mosquitto, ingestor, server, caddy) via supervisord. This is opaque to operators.
+5. **No pre-built images** — there's no image on Docker Hub or GHCR. Every operator must `git clone` + `docker compose build`.
+6. **Updates require rebuilding** — `git pull && docker compose build && docker compose up -d`. No `docker compose pull`.
+7. **manage.sh is 100+ lines** of bash wrapping `docker compose` with state files, confirmations, and color output. It's helpful for the maintainer but intimidating for new operators.
+
+### What works well
+
+- **Dockerfile is solid** — multi-stage Go build, Alpine runtime, small image
+- **Health checks exist** — `wget -qO- http://localhost:3000/api/stats`
+- **Environment variable overrides** — ports and data dirs are configurable via `.env`
+- **Data persistence** — bind mounts for DB (`~/meshcore-data`), named volume for Caddy certs
+- **DISABLE_MOSQUITTO flag** — can use external MQTT broker
+- **Graceful shutdown** — `stop_grace_period: 30s`, SIGTERM handling
+
+### What's painful
+
+| Pain Point | Impact |
+|---|---|
+| Must build from source | Blocks anyone without Go/Docker buildx knowledge |
+| 100-line config.json required | Operator doesn't know what's optional vs required |
+| No sensible defaults for MQTT | Can't connect to public mesh without credentials |
+| No pre-built multi-arch images | ARM users (Raspberry Pi) must cross-compile |
+| No one-line deploy | Minimum 4 steps: clone, configure, build, start |
+| Updates = rebuild | Slow, error-prone, requires git |
+
+## Goal
+
+An operator who has never seen the codebase should be able to run CoreScope with:
+
+```bash
+docker run -d -p 80:80 -v corescope-data:/app/data ghcr.io/kpa-clawbot/corescope:v3.4.1
+```
+
+And see live MeshCore packets from the public mesh within 60 seconds.
+
+## Pre-built Images
+
+Publish to **GHCR** (`ghcr.io/kpa-clawbot/corescope`) on every release tag.
+
+- **Tags:**
+  - `vX.Y.Z` (e.g., `v3.4.1`) — specific release, pinned, recommended for production
+  - `vX.Y` (e.g., `v3.4`) — latest patch in a minor series, auto-updates patches only
+  - `vX` (e.g., `v3`) — latest minor+patch in a major series
+  - `latest` — latest release tag (NOT latest commit). Only moves on tagged releases, never on random master commits. Still, production deployments should pin to `vX.Y.Z`
+  - `edge` — built from master on every push. Unstable, for testing only. Clearly labeled as such
+- **Architectures:** `linux/amd64`, `linux/arm64` (Raspberry Pi 4/5)
+- **Build trigger:** GitHub Actions on `v*` tag push
+- **CI workflow:** New job `publish` after existing `deploy`, uses `docker/build-push-action` with QEMU for multi-arch
+
+```yaml
+# .github/workflows/publish.yml (simplified)
+on:
+  push:
+    tags: ['v*']
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    permissions:
+      packages: write
+    steps:
+      - uses: actions/checkout@v5
+      - uses: docker/setup-qemu-action@v3
+      - uses: docker/setup-buildx-action@v3
+      - uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+      - uses: docker/build-push-action@v6
+        with:
+          push: true
+          platforms: linux/amd64,linux/arm64
+          tags: |
+            ghcr.io/kpa-clawbot/corescope:v3.4.1
+            ghcr.io/kpa-clawbot/corescope:${{ github.ref_name }}
+          build-args: |
+            APP_VERSION=${{ github.ref_name }}
+            GIT_COMMIT=${{ github.sha }}
+            BUILD_TIME=${{ github.event.head_commit.timestamp }}
+```
+
+## Configuration
+
+### Hierarchy (highest priority wins)
+
+1. **Environment variables** — `CORESCOPE_MQTT_BROKER`, `CORESCOPE_PORT`, etc.
+2. **`/app/data/config.json`** — full config file (volume-mounted)
+3. **Built-in defaults** — work out of the box
+
+### Environment variables for common settings
+
+| Variable | Default | Description |
+|---|---|---|
+| `CORESCOPE_MQTT_BROKER` | `mqtt://localhost:1883` | Primary MQTT broker URL |
+| `CORESCOPE_MQTT_TOPIC` | `meshcore/+/+/packets` | MQTT topic pattern |
+| `CORESCOPE_PORT` | `3000` | HTTP server port (internal) |
+| `CORESCOPE_DB_PATH` | `/app/data/meshcore.db` | SQLite database path |
+| `CORESCOPE_SITE_NAME` | `CoreScope` | Branding site name |
+| `CORESCOPE_DEFAULT_REGION` | (none) | Default region filter |
+| `DISABLE_MOSQUITTO` | `false` | Skip internal MQTT broker |
+| `DISABLE_CADDY` | `false` | Skip internal Caddy (when behind reverse proxy) |
+
+### Built-in defaults that work out of the box
+
+The Go server and ingestor already have reasonable defaults compiled in. The only missing piece is **a default public MQTT source** so a fresh instance can see packets immediately. Options:
+
+- **Option A:** Ship with the internal Mosquitto broker only (no external sources). Operator sees an empty dashboard and must configure MQTT. Safe but unhelpful.
+- **Option B:** Ship with a public read-only MQTT source pre-configured (e.g., `mqtt.meshtastic.org` or equivalent if one exists for MeshCore). Operator sees live data immediately. Better UX.
+
+**Recommendation:** Option A as default (safe), with a documented one-liner to add a public source. The config.example.json already shows how to add `mqttSources`.
+
+## Compose Profiles
+
+A single `docker-compose.yml` with profiles:
+
+```yaml
+services:
+  corescope:
+    image: ghcr.io/kpa-clawbot/corescope:v3.4.1
+    profiles: ["", "standard", "full"]  # runs in all profiles
+    ports:
+      - "${HTTP_PORT:-80}:80"
+    volumes:
+      - ${DATA_DIR:-./data}:/app/data
+    environment:
+      - DISABLE_MOSQUITTO=${DISABLE_MOSQUITTO:-false}
+      - DISABLE_CADDY=${DISABLE_CADDY:-false}
+    healthcheck:
+      test: ["CMD", "wget", "-qO-", "http://localhost:3000/api/stats"]
+      interval: 30s
+      timeout: 5s
+      retries: 3
+    restart: unless-stopped
+```
+
+**Note:** Since the container already bundles mosquitto + caddy + server + ingestor via supervisord, "profiles" are really just env var toggles:
+
+| Profile | DISABLE_MOSQUITTO | DISABLE_CADDY | Use case |
+|---|---|---|---|
+| **minimal** | `true` | `true` | External MQTT + external reverse proxy |
+| **standard** (default) | `false` | `true` | Internal MQTT, no TLS (behind nginx/traefik) |
+| **full** | `false` | `false` | Everything including Caddy auto-TLS |
+
+This avoids splitting into separate compose services. The monolithic container is actually fine for this use case — it's a single-purpose appliance.
+
+## One-Line Deploy
+
+### Simplest (Docker run, no TLS)
+
+```bash
+docker run -d --name corescope \
+  -p 80:80 \
+  -v corescope-data:/app/data \
+  -e DISABLE_CADDY=true \
+  ghcr.io/kpa-clawbot/corescope:v3.4.1
+```
+
+### With Docker Compose
+
+```bash
+curl -sL https://raw.githubusercontent.com/Kpa-clawbot/CoreScope/master/docker-compose.simple.yml -o docker-compose.yml
+docker compose up -d
+```
+
+Where `docker-compose.simple.yml` is a minimal 15-line file shipped in the repo.
+
+## Update Path
+
+```bash
+docker compose pull
+docker compose up -d
+```
+
+Or for `docker run` users:
+
+```bash
+docker pull ghcr.io/kpa-clawbot/corescope:v3.4.1
+docker stop corescope && docker rm corescope
+docker run -d --name corescope ... # same args as before
+```
+
+No rebuild. No git pull. No source code needed.
+
+## Data Persistence
+
+| Path | Content | Mount |
+|---|---|---|
+| `/app/data/meshcore.db` | SQLite database (all packets, nodes) | Required volume |
+| `/app/data/config.json` | Custom configuration (optional) | Same volume |
+| `/app/data/theme.json` | Custom theme (optional) | Same volume |
+| `/data/caddy` | TLS certificates (Caddy-managed) | Named volume (automatic) |
+
+**Backup:** `cp ~/corescope-data/meshcore.db ~/backup/` — it's just a SQLite file.
+
+**Migration:** Existing `~/meshcore-data` directories work unchanged. Just point the volume at the same path.
+
+## TLS/HTTPS
+
+### Option 1: Caddy auto-TLS (built-in)
+
+The container ships Caddy. To enable auto-TLS:
+
+1. Mount a custom Caddyfile:
+   ```bash
+   docker run -d \
+     -p 80:80 -p 443:443 \
+     -v corescope-data:/app/data \
+     -v caddy-certs:/data/caddy \
+     -v ./Caddyfile:/etc/caddy/Caddyfile:ro \
+     ghcr.io/kpa-clawbot/corescope:v3.4.1
+   ```
+
+2. Caddyfile:
+   ```
+   your-domain.com {
+     reverse_proxy localhost:3000
+   }
+   ```
+
+### Option 2: External reverse proxy (recommended for production)
+
+Run with `DISABLE_CADDY=true` and put nginx/traefik/cloudflare in front. This is the standard approach and what most operators already have.
+
+## Health Checks
+
+Already implemented. The container health check hits `/api/stats`:
+
+```bash
+# From outside the container
+curl -f http://localhost/api/stats
+
+# Response includes packet counts, node counts, uptime
+```
+
+Docker will mark the container as `healthy`/`unhealthy` automatically.
+
+## Monitoring
+
+**Future (M5 from RF health spec):** Expose a `/metrics` Prometheus endpoint with:
+
+- `corescope_packets_total` — total packets ingested
+- `corescope_nodes_active` — currently active nodes
+- `corescope_mqtt_connected` — MQTT connection status
+- `corescope_ingestor_lag_seconds` — time since last packet
+
+This is not required for the deployment simplification work but should be designed alongside it.
+
+## Migration from Current Setup
+
+For existing operators using `manage.sh` + build-from-source:
+
+1. **Keep your data directory** — the bind mount path is the same
+2. **Keep your config.json** — it goes in the data directory as before
+3. **Replace `docker compose build`** with `docker compose pull`
+4. **Update docker-compose.yml** — change `build:` to `image: ghcr.io/kpa-clawbot/corescope:v3.4.1`
+5. **manage.sh continues to work** — it wraps `docker compose` and will work with pre-built images
+
+**Breaking changes:** None expected. The container interface (ports, volumes, env vars) stays the same.
+
+## Milestones
+
+### M1: Pre-built images (1-2 days)
+- [ ] Create `.github/workflows/publish.yml` for multi-arch builds
+- [ ] Push a test `v0.x.0` tag and verify image on GHCR
+- [ ] Update README with `docker run` quickstart
+- [ ] Create `docker-compose.simple.yml` (minimal compose file using pre-built image)
+
+### M2: Environment variable configuration (1 day)
+- [ ] Add env var parsing to Go server `config.go` (overlay on config.json)
+- [ ] Add env var parsing to Go ingestor
+- [ ] Add `DISABLE_CADDY` support to `entrypoint-go.sh`
+- [ ] Document all env vars in README
+
+### M3: Sensible defaults (0.5 day)
+- [ ] Ensure server starts with zero config (no config.json required)
+- [ ] Verify ingestor connects to localhost MQTT by default
+- [ ] Test: `docker run` with no config produces a working (empty) dashboard
+
+### M4: Documentation + migration guide (0.5 day)
+- [ ] Write operator-facing deployment docs in `docs/deployment.md`
+- [ ] Migration guide for existing users
+- [ ] One-page quickstart
+
+**Total estimate:** 3-4 days of work.
+
+## Torvalds Review
+
+> "Is this over-engineered?"
+
+The spec is intentionally simple. Key decisions:
+
+1. **No Kubernetes manifests, Helm charts, or Terraform.** Just Docker.
+2. **No config management system.** Env vars + optional JSON file.
+3. **Keep the monolithic container.** Splitting into 4 separate services (server, ingestor, mosquitto, caddy) would be "proper" microservices but is worse for operators who just want one thing to run. The supervisord approach is fine for an appliance.
+4. **No custom CLI tool.** `docker compose` is the interface.
+5. **Profiles are just env vars**, not separate compose files or services.
+
+The simplest version is literally just M1: publish the existing image to GHCR. Everything else is polish. An operator can already `docker run` the image — they just can't `docker pull` it because it's not published anywhere.

docs/specs/movable-ui-panels.md

@@ -0,0 +1,141 @@
+# Movable UI Panels — Draggable Panel Positioning
+
+**Status:** Proposed  
+**Related:** #279 (original request), PR #606 (collapsible panels — immediate fix)  
+**Date:** 2026-04-05
+
+---
+
+## Problem
+
+The live map page overlays several UI panels on the map viewport: legend, live feed, node detail, and filters. On smaller screens or dense deployments, these panels obscure map content. Users have no control over where panels sit — they're CSS-fixed in corners, and when they collide with each other or with map data, the only option is to close them entirely. Closing a panel means losing access to the data it shows.
+
+PR #606 addresses the immediate pain with collapsible panels and responsive breakpoints. This spec covers the next step: letting users reposition panels to wherever serves their workflow best.
+
+## Solution
+
+Panels become draggable within the map viewport. Users grab a handle, drag to a new position, release. Position persists in `localStorage` per panel ID. That's it.
+
+### What each panel gets
+
+| Affordance | Behavior |
+|---|---|
+| **Drag handle** | A subtle grip indicator (6-dot grid or `⋮⋮`) in the panel header. Cursor changes to `grab`/`grabbing`. The handle is the ONLY drag target — the panel body remains interactive (scrollable, clickable). |
+| **Snap-to-edge** | When released within 20px of a viewport edge, the panel snaps flush to that edge. Prevents panels floating 3px from the side looking broken. |
+| **Position persistence** | `localStorage` key per panel: `panel-pos-{id}` → `{ x, y }` as viewport percentages (not pixels — survives resize). |
+| **Z-index on focus** | Clicking or dragging a panel brings it to front. Simple incrementing counter, reset on page load. |
+| **Reset button** | Single button (in settings or as a map control) resets ALL panels to default positions. Clears all `panel-pos-*` keys. |
+
+### What we do NOT build
+
+- **Resizable panels.** Drag-to-resize adds complexity for marginal benefit. Panels have natural content-driven sizes.
+- **Docking/tiling/splitting.** This is not a window manager. No snap-to-other-panel, no split view, no tiling grid.
+- **Panel minimization to a taskbar.** Collapsible (PR #606) is sufficient.
+- **Drag on mobile.** Touch-drag conflicts with map pan. Mobile keeps collapsible behavior from PR #606. Draggable is desktop-only (`pointer: fine` media query).
+
+## Design Considerations
+
+### Drag handle affordance
+
+The handle must be visible enough that users discover it, but not so prominent that it becomes visual noise. A 6-dot grip icon (`⋮⋮`) in the panel title bar, styled at 60% opacity, rising to 100% on hover. The cursor change (`grab` → `grabbing`) provides the primary affordance.
+
+### Snap-to-edge
+
+Panels snap to the nearest edge when released within a 20px threshold. Snap positions: top-left, top-right, bottom-left, bottom-right, or any edge midpoint. This prevents the "floating at 47px from the left" awkwardness without constraining users to a rigid grid.
+
+### Position persistence
+
+Positions stored as viewport percentages: `{ xPct: 0.02, yPct: 0.15 }`. On window resize, panels stay proportionally positioned. If a resize would push a panel off-screen, clamp it to the nearest visible edge.
+
+### Responsive breakpoints
+
+Below the medium breakpoint (defined in PR #606), panels revert to their fixed/collapsible positions. The draggable behavior is a progressive enhancement for viewports wide enough to have meaningful repositioning space. Persisted positions are preserved in `localStorage` but not applied until the viewport is wide enough again.
+
+### Z-index management
+
+A module-level counter starting at 1000. Each panel interaction (click, drag start) sets that panel's z-index to `++counter`. On page load, counter resets to 1000. No panel can exceed z-index 9999 (modal/overlay territory) — if counter approaches that, compact all panel z-indices down.
+
+### Accessibility
+
+- Panels are focusable (`tabindex="0"` on the drag handle).
+- Arrow keys reposition the focused panel by 10px per press (Shift+Arrow = 50px).
+- `Escape` while dragging cancels and returns to the previous position.
+- `Home` key resets the focused panel to its default position.
+- Screen readers: `aria-label="Drag handle for {panel name}. Use arrow keys to reposition."` and `role="slider"` with `aria-valuenow` reflecting position.
+
+## Implementation
+
+### Milestones
+
+**M1: Core drag mechanics** (~2 days)
+- `DragManager` class: registers panels, handles pointer events, updates positions
+- Snap-to-edge logic
+- Z-index management
+- No persistence yet — positions reset on reload
+
+**M2: Persistence + reset** (~1 day)
+- `localStorage` read/write for panel positions
+- Reset-to-defaults button
+- Viewport-percentage storage with resize clamping
+
+**M3: Responsive + accessibility** (~1 day)
+- Disable drag below medium breakpoint
+- Keyboard repositioning (arrow keys)
+- ARIA attributes
+- Screen reader announcements on position change
+
+**M4: Polish + testing** (~1 day)
+- Playwright E2E tests: drag, snap, persist, reset, keyboard
+- Performance validation: drag must not trigger layout thrash (use `transform: translate()`, not `top/left`)
+- Edge case handling (see below)
+
+### Technical approach
+
+- **No library.** Pointer events (`pointerdown`, `pointermove`, `pointerup`) with `setPointerCapture`. ~150 lines of vanilla JS.
+- **CSS transforms for positioning.** `transform: translate(Xpx, Ypx)` avoids layout reflow during drag. Only write to `style.transform`, never `top`/`left`.
+- **Debounce persistence.** Write to `localStorage` on `pointerup`, not during drag.
+- **Single file:** `public/drag-manager.js` — imported by `live.js`, no other dependencies.
+
+## Edge Cases
+
+| Case | Handling |
+|---|---|
+| Panel dragged partially off-screen | Clamp to viewport bounds on `pointerup` |
+| Window resized while panel is near edge | Re-clamp on `resize` (debounced 200ms) |
+| Two panels overlap after drag | Allowed — z-index determines which is on top. Users can move them. |
+| `localStorage` full or unavailable | Graceful fallback to default positions. No error shown. |
+| Panel content changes size after drag | Panel stays at dragged position; content reflows within. If panel grows past viewport edge, clamp. |
+| User has old `localStorage` keys from a removed panel | Ignore unknown keys on load. Clean up stale keys on reset. |
+| RTL layouts | Snap logic uses physical viewport edges, not logical start/end. Drag is inherently physical. |
+
+## Expert Reviews
+
+### Tufte (Information Design)
+
+- **Draggability is justified** only if it serves data access — and here it does. Panels obscuring map data is a data-visibility problem, not a UI-decoration problem. Letting users clear their sightlines to the data is correct.
+- **The drag handle must be minimal.** Six dots at 60% opacity is acceptable. Anything more prominent (colored bars, icons, labels) becomes chartjunk — UI chrome competing with data for attention.
+- **Resist feature creep.** Resizable panels, docking zones, panel-to-panel snapping — all increase interface complexity without increasing data throughput. The spec correctly excludes these.
+- **Snap-to-edge is good.** It prevents the visual noise of arbitrarily placed rectangles. Panels aligned to edges create clean negative space for the map data.
+
+### Torvalds (Engineering Pragmatism)
+
+- **This is borderline over-engineering.** The real question: do users actually need free-form drag, or would a simpler "pick a corner" toggle (TL/TR/BL/BR) cover 95% of use cases with 20% of the code?
+- **The 4-corner toggle would be ~40 lines.** The full drag system is ~150+ lines plus persistence, snap logic, accessibility, resize handling, z-index management, and edge cases. That's a lot of surface area for "I want the legend on the right instead of the left."
+- **Recommendation:** Ship the 4-corner toggle first (M0). If users actually request free-form drag after that, build it. YAGNI applies here.
+- **If you do build drag:** the spec is sound. Pointer events + transforms + localStorage is the right stack. No library is correct. But test it on Firefox — pointer capture has quirks.
+
+### Doshi (Product/Business)
+
+- **This is an N (Nice-to-have), not an L (Leverage).** It improves UX for power users who spend hours on the live map, but it doesn't unlock new capabilities or new users.
+- **Opportunity cost:** 5 developer-days on draggable panels is 5 days not spent on features that expand what CoreScope can do (new analytics, alerting, multi-site support).
+- **The collapsible panels (PR #606) likely resolve the P1 pain.** Track whether users still complain about panel placement after #606 ships. If complaints drop to zero, this spec can stay on the shelf.
+- **If built:** ship M1+M2 only (3 days). M3 accessibility can come later if adoption warrants it. M4 testing is non-negotiable.
+
+### Feedback incorporated
+
+Based on the reviews, the spec adds a **Milestone 0** recommendation:
+
+**M0: Corner-position toggle** (~0.5 days)  
+Before building full drag, ship a simpler panel-position toggle: each panel's header gets a small button that cycles through TL → TR → BR → BL placement. Positions persist in `localStorage`. If this satisfies user needs, M1–M4 become unnecessary.
+
+**Decision gate:** Ship M0 with PR #606 or shortly after. Monitor feedback for 2 weeks. If users request free-form repositioning, proceed to M1. If corner toggle is sufficient, close this spec as "resolved by M0."

docs/specs/rf-health-dashboard.md

@@ -0,0 +1,493 @@
+# Spec: RF Health Dashboard — Observer Radio Metrics
+
+**Status:** Draft v3
+**Purpose:** Enable operators to quickly identify RF jammers, deaf receivers, and radio health issues through per-observer time-series charts.
+
+## Prerequisite Gate
+
+**Before building anything, verify that stats messages arrive periodically from observers.**
+
+The ingestor must receive radio stats messages at a predictable interval via MQTT. Confirmed: status messages arrive every ~5 minutes per observer.
+
+**Verification steps (M0):**
+1. Connect ≥3 observers to the MQTT bridge
+2. Log all incoming stats messages with timestamps for 24h
+3. Confirm messages arrive at a regular interval (expected: every few minutes)
+4. If stats are NOT periodic, stop — a stats-request mechanism must be added to the MQTT bridge first (separate spec)
+5. **Verify `triggerNoiseFloorCalibrate()` firing frequency.** If it fires on every stats cycle, noise floor readings may be artificially consistent (measuring calibration, not environment). If it fires only on boot, the first sample after reboot is unreliable — document which behavior the firmware uses.
+
+Do not proceed to M1 until this gate passes.
+
+## Problem
+
+Operators currently have no visibility into RF environment quality over time. A jammer could be active for hours before anyone notices degraded mesh performance. A deaf receiver silently drops packets with no alert. There's no way to distinguish "the mesh is quiet" from "my observer can't hear anything."
+
+## Solution
+
+A new Analytics tab ("RF Health") showing per-observer time-series charts for noise floor, TX airtime, RX airtime, and receive errors over configurable time windows (1h to 30d, plus custom from/to range). Automated pattern detection (M3+) flags anomalies and suggests diagnoses after operators have used raw charts to provide feedback.
+
+## Data Model
+
+### New table: `observer_metrics`
+
+```sql
+CREATE TABLE IF NOT EXISTS observer_metrics (
+    observer_id TEXT NOT NULL,
+    timestamp TEXT NOT NULL,       -- ISO 8601, rounded to nearest sample interval
+    noise_floor REAL,              -- dBm, from radio stats (nullable — may arrive without airtime)
+    tx_air_secs INTEGER,           -- cumulative TX seconds since boot (nullable)
+    rx_air_secs INTEGER,           -- cumulative RX seconds since boot (nullable)
+    packets_sent INTEGER,          -- cumulative packets sent since boot (nullable)
+    packets_recv INTEGER,          -- cumulative packets received since boot (nullable)
+    recv_errors INTEGER,           -- cumulative CRC/decode failures since boot (nullable)
+    battery_mv INTEGER,            -- battery voltage in millivolts (nullable, for field/solar nodes)
+    PRIMARY KEY (observer_id, timestamp)
+);
+```
+
+**Field notes:**
+
+- **`recv_errors`** (CRC failure count) is the strongest single indicator of channel quality. A rising error rate with stable noise floor points to in-band digital interference rather than broadband jamming. This is more diagnostic than packet_count alone.
+- **`packets_sent` / `packets_recv`** are tracked separately because the ratio reveals asymmetric link problems (e.g., observer can transmit but not receive, or vice versa). The old `packet_count` field conflated these.
+- **`battery_mv`** is nullable and only relevant for field/solar deployments. Low battery causes erratic radio behavior (reduced TX power, missed RX windows) that looks like RF problems but isn't. Charting voltage alongside RF metrics prevents misdiagnosis.
+- All cumulative counters (`tx_air_secs`, `rx_air_secs`, `packets_sent`, `packets_recv`, `recv_errors`) reset on reboot — see reboot handling below.
+
+No additional indexes. The composite primary key covers all query patterns (per-observer time-range scans). At 70K rows, a full scan for any fleet-wide time query is fast enough.
+
+### Clock source
+
+**Always use the ingestor's wall clock for timestamps, not observer-reported timestamps.** Observer clocks may be wrong, drifted, or absent (no RTC). Round the ingestor wall clock to the nearest sample interval boundary (e.g., 5-minute marks) for consistent time alignment.
+
+### Noise floor cold start caveat
+
+**The first noise floor sample after a reboot may be unreliable.** The radio's noise floor reading requires settling time and may reflect calibration artifacts rather than the actual RF environment. Mark the first post-reboot sample with a `reboot` flag (see reboot handling) so the frontend can annotate it. Do not use first-post-reboot noise floor samples in baseline/median calculations.
+
+### Sampling strategy
+
+- **Interval:** Every 5 minutes (configurable via config.json `metrics.sampleIntervalSec`, default 300)
+- **Source:** MQTT stats messages (`STATS_TYPE_RADIO`)
+- **Insertion:** `INSERT OR REPLACE INTO observer_metrics (observer_id, timestamp, ...) VALUES (?, ?, ...)` with timestamp rounded to the nearest interval boundary. No need to track last-insert time per observer — rounding + `INSERT OR REPLACE` is idempotent and naturally deduplicates.
+- **Storage:** ~10K rows/day for 35 observers. At configurable retention. Negligible.
+- **Retention:** Configurable, configurable, default 30 days. Prune with a single `DELETE FROM observer_metrics WHERE timestamp < datetime('now', '-N days')` on startup and every 24h. Consider `PRAGMA auto_vacuum = INCREMENTAL` for embedded devices.
+
+### Gap detection
+
+If the time between two consecutive samples for an observer exceeds 2× the sample interval (e.g., >10 minutes for a 5-min interval), insert null values in the response to indicate a gap. This prevents charts from drawing misleading interpolation lines across outages.
+
+### Reboot handling
+
+Cumulative counters (`tx_air_secs`, `rx_air_secs`, `packets_sent`, `packets_recv`, `recv_errors`) reset on device reboot. Detect counter resets (current value < previous value) and:
+1. Skip the delta computation for that interval (do not produce a negative value)
+2. Log a reboot event for the observer with the timestamp
+3. Use the current sample as the new baseline for subsequent deltas
+4. **Include reboot timestamps in the API response** so the frontend can render them as annotations directly on the chart (see frontend design)
+5. **Flag the first post-reboot noise floor sample** as potentially unreliable (cold start — see above)
+
+### Delta computation (server-side)
+
+Cumulative counters are converted to per-interval rates server-side. **Deltas are computed server-side, not in the frontend.** The API returns percentage/rate values directly. This keeps firmware implementation details (cumulative counters, reboot semantics) out of the UI layer, reduces payload size, and centralizes reboot-handling logic.
+
+### Graceful degradation
+
+Not all observers may report all metrics. If fields are absent:
+- Store `NULL` for missing columns
+- The API returns `null` for unavailable fields
+- The frontend shows only the charts for which data exists — missing charts are hidden, not broken
+- Status detection uses only available metrics
+- `battery_mv` is expected to be absent on mains-powered observers — this is normal, not an error
+
+Partial data is always better than no data. Never error or crash on missing optional fields.
+
+### Required ingestor changes
+
+1. Parse `tx_air_secs`, `rx_air_secs`, `packets_sent`, `packets_recv`, `recv_errors`, and `battery_mv` from MQTT stats messages (same pattern as existing `noise_floor`)
+2. On each stats message, round ingestor wall clock to nearest interval, `INSERT OR REPLACE` into `observer_metrics`
+3. Handle missing fields gracefully (insert NULLs for absent metrics)
+4. Detect counter resets and record reboot events
+5. Add new columns to `observers` table for current/latest values
+
+### API endpoints
+
+```
+GET /api/observers/{id}/metrics?since=2026-04-04T00:00:00Z&until=2026-04-05T00:00:00Z&resolution=5m
+```
+
+**`resolution` query parameter** controls downsampling:
+- `5m` (default) — raw samples
+- `1h` — hourly aggregates (`GROUP BY strftime('%Y-%m-%dT%H:00:00', timestamp)` with MIN/MAX/AVG)
+- `1d` — daily aggregates
+
+Use `1h` resolution for 7d views to avoid shipping 2,016 points per observer. Essential for the fleet comparison view (35 observers × 2,016 = 70K points at raw resolution → 35 × 168 = 5,880 points at 1h resolution).
+
+Returns:
+```json
+{
+  "observer_id": "1F445B...",
+  "observer_name": "GY889 Repeater",
+  "reboots": ["2026-04-04T03:15:00Z", "2026-04-04T18:22:00Z"],
+  "metrics": [
+    {
+      "timestamp": "2026-04-04T00:00:00Z",
+      "noise_floor": -112.5,
+      "tx_airtime_pct": 2.1,
+      "rx_airtime_pct": 8.3,
+      "packets_sent": 42,
+      "packets_recv": 342,
+      "recv_errors": 3,
+      "recv_error_rate": 0.87,
+      "battery_mv": 3720,
+      "is_reboot_sample": false
+    }
+  ]
+}
+```
+
+Notes:
+- `tx_airtime_pct` and `rx_airtime_pct` are server-computed deltas as percentages. Null if airtime data unavailable.
+- `recv_error_rate` = `recv_errors / (packets_recv + recv_errors)` as a percentage. Null if either field unavailable.
+- `packets_sent` and `packets_recv` are per-interval deltas (not cumulative). Null if unavailable.
+- `reboots` array contains timestamps of detected reboots within the queried window, for chart annotation.
+- `is_reboot_sample` flags first-post-reboot samples where noise floor may be unreliable.
+- `battery_mv` is null for mains-powered observers.
+
+```
+GET /api/observers/metrics/summary?window=24h
+```
+
+**Fleet summary is cached incrementally.** Maintain a rolling summary struct in memory, updated on each new sample insert (35 observers × 1 sample/5min = 7 inserts/min — trivially cheap). The endpoint reads from the cached struct, not from SQLite queries on every request.
+
+Returns:
+```json
+{
+  "observers": [
+    {
+      "observer_id": "1F445B...",
+      "observer_name": "GY889 Repeater",
+      "current_noise_floor": -112.5,
+      "avg_noise_floor_24h": -114.2,
+      "max_noise_floor_24h": -95.0,
+      "tx_airtime_pct_24h": 2.1,
+      "rx_airtime_pct_24h": 8.3,
+      "recv_error_rate_24h": 0.87,
+      "battery_mv": 3720,
+      "status": "normal"
+    }
+  ]
+}
+```
+
+## Frontend Design
+
+### Design Principles
+
+The dashboard exists for one purpose: **let an operator glance at it at 3 AM and know immediately if something is wrong.** Every design decision follows from this. Decoration that doesn't serve comprehension is removed. Data that can be shown is shown — not hidden behind clicks or hovers.
+
+Key rules (per Tufte):
+- **Maximize data-ink ratio.** Every pixel must encode data or directly support reading it. Remove anything that doesn't.
+- **No chartjunk.** No gradient fills, no 3D effects, no decorative borders, no ornamental chrome.
+- **Labels on the data, not in legends.** Direct-label lines, annotate anomalies at the point they occur. The viewer should never look away from the data to understand it.
+- **Show data variation, not design variation.** All observer charts use identical scales, formats, and typography. If two charts look different, it's because the data is different.
+- **Respect the viewer's intelligence.** Dense, information-rich displays are fine. Oversimplified displays waste screen space and the operator's time.
+
+### Page structure: small multiples grid
+
+```
+Analytics → RF Health tab
+├── Time range: [1h] [3h] [6h] [12h] [24h] [3d] [7d] [30d] [Custom ▾]
+│   ├── Presets: click to quick-set
+│   └── Custom: two datetime inputs (from/to) with calendar picker
+│       └── URL hash reflects selected range for deep linking
+│
+├── Small Multiples Grid (ALL observers, one cell per observer)
+│   │
+│   │  Each cell contains:
+│   │  ┌─────────────────────────────────────────┐
+│   │  │ GY889 Repeater          -112.5 dBm  3.7V│  ← name, current NF, battery (if field node)
+│   │  │ ┈┈┈╲┈┈┈┈┈┈╱┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈│  ← noise floor sparkline (24h)
+│   │  │ err: 0.8%  TX: 2.1%  RX: 8.3%          │  ← key rates, inline text
+│   │  │ ▲reboot 03:15                           │  ← reboot annotation (if any)
+│   │  └─────────────────────────────────────────┘
+│   │
+│   │  Sorted by: worst status first, then highest noise floor
+│   │  Grid: 3–4 columns on desktop, 2 on tablet, 1 on phone
+│   │  Click any cell → expand to full detail below
+│   │
+│   └── Entire grid is visible at once — no pagination, no "show more"
+│       (35 observers × ~60px per cell = ~700px — fits on one screen)
+│
+├── Expanded Detail (shown below grid when a cell is clicked)
+│   │
+│   │  Three time-aligned charts, stacked vertically, sharing X-axis:
+│   │
+│   │  1. Noise Floor (dBm)
+│   │     - SVG line chart, Y-axis inverted (higher dBm = worse = higher on chart)
+│   │     - Thin reference lines at -100 dBm and -85 dBm, directly labeled
+│   │       (e.g., "−100 warning" / "−85 critical") — no color bands
+│   │     - Gaps (nulls) break the line — no interpolation across outages
+│   │     - Reboot markers: vertical hairline at each reboot timestamp,
+│   │       labeled "reboot" directly on the chart
+│   │     - First-post-reboot sample marked with open circle (unreliable cold start)
+│   │     - Direct labels on notable points (min, max, anomalies)
+│   │
+│   │  2. Airtime (%) — hidden if no airtime data
+│   │     - Two separate SVG lines (NOT stacked area — stacked areas
+│   │       make it impossible to read the lower series accurately)
+│   │     - TX line and RX line, directly labeled at their endpoints
+│   │       ("TX 2.1%" / "RX 8.3%") — no legend box
+│   │     - Same X-axis as noise floor chart above
+│   │     - Gaps shown as breaks
+│   │
+│   │  3. Channel Quality
+│   │     - Receive error rate (%) as a line
+│   │     - Packets recv as a light step-line for context
+│   │     - Directly labeled — no legend
+│   │     - High error rate + low packet count = dead channel
+│   │     - High error rate + high packet count = interference
+│   │
+│   │  4. Battery Voltage (shown only if battery_mv is non-null)
+│   │     - Simple line chart, mV scale
+│   │     - Directly labeled with current value
+│   │     - Useful for correlating RF anomalies with low-battery behavior
+│   │
+│   │  All four charts share the same X-axis and time range.
+│   │  Reboot markers appear as vertical hairlines across ALL charts
+│   │  (same event, visible in all contexts — no hunting).
+│   │
+│   └── Current values shown as text below charts:
+│       NF: −112.5 dBm | TX: 2.1% | RX: 8.3% | Err: 0.87% | Batt: 3.72V
+│       24h: avg −114.2 | max −95.0 | 3 reboots
+│
+└── Fleet Comparison (M4)
+    └── Small multiples of noise floor, one per observer, identical Y-scale
+    └── NOT an overlay chart — overlays become unreadable past 5 lines
+    └── Use 1h resolution for 7d views
+```
+
+### Why small multiples, not expandable accordion
+
+An accordion (expand/collapse per observer) forces the operator to click through each observer sequentially. At 3 AM with 35 observers, that's unacceptable. The small multiples grid shows ALL observers simultaneously — the eye does the comparison, not the mouse. Anomalies pop out visually because they break the pattern of the grid. This is Tufte's core insight: **small multiples leverage the viewer's ability to detect pattern breaks across a consistent visual template.**
+
+### Why no color bands on charts
+
+Color bands (green/yellow/red zones) are decorative — they add ink that doesn't encode data. They also pre-judge what's "good" and "bad," which varies by deployment environment. Instead, use **thin reference lines with direct text labels** at the warning and critical thresholds. The reference lines take up negligible ink, the labels are informational, and the operator's eye naturally compares the data line against them.
+
+### Why not stacked area for airtime
+
+Stacked area charts are a common source of graphical dishonesty. The bottom series (TX) reads correctly against the X-axis, but the top series (RX) reads against the TX boundary — making it impossible to accurately judge RX values without mental subtraction. Two separate lines, directly labeled, are always more honest and more readable.
+
+### Color usage
+
+Color encodes data category, never decoration:
+- **Noise floor line:** single muted color (the line IS the data — it doesn't need to be loud)
+- **TX / RX lines:** two distinct colors, directly labeled at endpoints (no legend needed)
+- **Error rate:** a third distinct color
+- **Reboot markers:** gray hairlines (de-emphasized — context, not data)
+- **Status text in grid cells:** text color only (not background fill) — red text for critical, amber for warning, default for normal
+- No background color fills on cards. No colored borders. No badge backgrounds. Color on text only where it carries meaning.
+
+### Labels and annotations
+
+- **Reference lines** at threshold values, labeled directly ("−100 dBm warning")
+- **Reboot events** as vertical hairlines across all charts, labeled "reboot" at the top
+- **Cold-start samples** marked with open circles and a subtle "?" annotation
+- **Current values** as inline text on the sparkline cells and below detail charts
+- **No separate legends.** Lines are labeled at their endpoints or directly on the chart.
+- **Hover** shows exact timestamp + value — this is the only interactive element, and it reveals precision, not hidden data
+
+### Data density
+
+- The small multiples grid fits 35 observers in ~700px vertical space (one screen on desktop)
+- Each cell is information-dense: name + current value + sparkline + rates + reboot count — all visible without clicking
+- Detail charts are stacked vertically sharing the X-axis, eliminating redundant time labels
+- No wasted whitespace between chart panels — they are a single visual unit
+
+### Information hierarchy (3 AM glance test)
+
+1. **Grid scan (2 seconds):** Are all sparklines flat and similar? Yes → everything's fine. One cell has a spike or red text → that's the problem.
+2. **Cell read (3 seconds):** Which observer, what's the current NF, what's the error rate? All visible without clicking.
+3. **Detail dive (10 seconds):** Click the cell, see time-series context, see if it correlates with reboots, check battery, check airtime.
+
+An operator never needs to click anything to know if the fleet is healthy. Clicking only provides temporal detail for diagnosis.
+
+### Mobile considerations
+
+- Grid collapses to 1 column on phone (each cell is full-width, still showing sparkline + values)
+- Detail charts fill the viewport width, Y-axis labels move above the chart to save horizontal space
+- Touch targets: the entire grid cell is tappable (not a small icon)
+- Time range selector uses segmented control (large touch targets) for presets, not a dropdown
+- Custom range picker: two datetime inputs with calendar popup, positioned below the presets
+- Selected range (preset or custom) persists in URL hash: `&range=24h` or `&from=2026-04-04T14:00:00Z&to=2026-04-04T16:00:00Z`
+
+### Chart rendering
+
+**Use SVG, not Canvas.** The existing analytics.js uses SVG for all charts (sparklines, bar charts, histograms). Canvas is only used for the force-directed neighbor graph. Follow the existing SVG patterns — reuse `sparkSvg()` for fleet overview sparklines.
+
+2,016 SVG polyline points per chart is fine. For the fleet comparison view (M4), use hourly downsampling (168 points per observer) to avoid layout jank on mobile.
+
+### Deep linking
+
+```
+#/analytics?tab=rf-health
+#/analytics?tab=rf-health&observer=1F445B...&range=24h
+```
+
+## Pattern Detection (M3+)
+
+**Pattern detection is deferred until after operators have used raw charts (M1–M2) and provided feedback on what patterns actually matter.** Do not implement automated diagnosis until real-world usage informs the rules.
+
+### Planned automated diagnosis
+
+The server computes a `status` field per observer based on the last N samples:
+
+| Pattern | Status | Indicator |
+|---|---|---|
+| NF stable, RX/TX normal, low error rate | `normal` | (no indicator — absence of alarm is the signal) |
+| NF spike + RX drop (broadband interference) | `jammer_suspected` | Red text: "Jammer?" |
+| NF normal, RX near zero, fleet active (≥5 observers) | `deaf` | Red text: "Deaf receiver" |
+| High `recv_errors` rate + stable NF | `digital_interference` | Amber text: "CRC errors high" |
+| TX approaching duty cycle warning | `tx_overload` | Amber text: "TX overload" |
+| No samples in >15 min | `offline` | Gray text: "Offline" |
+| NF gradually increasing over hours | `interference_trend` | Amber text: "Rising interference" |
+| Battery voltage below threshold | `low_battery` | Amber text: "Low battery" |
+
+**Jammer detection logic:** A jammer raises the noise floor AND causes RX to drop (the receiver can't hear legitimate signals over the interference). NF spike + RX spike would indicate a legitimate busy channel, not a jammer. The key signal is: NF goes up, RX goes down.
+
+**Digital interference detection (new):** High `recv_errors` with a stable noise floor indicates in-band digital interference (another protocol sharing the frequency, or a malfunctioning node transmitting garbage). This is distinct from broadband jamming, which raises the noise floor. `recv_errors` is the strongest single signal for this.
+
+**Deaf detection:** Requires a minimum fleet size of ≥5 active observers to establish a meaningful fleet median. With fewer observers, skip deaf detection — the sample size is too small for comparison.
+
+### Status priority
+
+When multiple status conditions apply simultaneously, use this priority order (highest first):
+1. `offline` — no data trumps everything
+2. `jammer_suspected` — active threat
+3. `deaf` — hardware failure
+4. `digital_interference` — channel quality issue
+5. `tx_overload` — regulatory concern
+6. `low_battery` — power issue causing RF symptoms
+7. `interference_trend` — gradual degradation
+8. `normal` — default
+
+### Baseline computation
+
+- **Baseline noise floor:** rolling median of last 24h, **excluding first-post-reboot samples** (cold start unreliable). Computed once on new sample arrival, cached — not recomputed per request.
+- **Spike detection:** current sample exceeds an absolute threshold (configurable) AND exceeds baseline + spike delta. Both conditions must be met — a delta-only threshold could false-positive in environments where the absolute NF is already benign (e.g., -115 dBm + 15 dBm = -100 dBm, which is fine).
+- **"Others active" check for deaf detection:** compare this observer's RX packet count against the fleet median. If this observer is <10% of fleet median AND fleet has ≥5 active observers, flag as potentially deaf.
+- **Error rate baseline:** rolling average of `recv_error_rate` over 24h. Spike above 2× baseline triggers `digital_interference` status.
+
+### Alert thresholds (configurable)
+
+```json
+{
+  "rfHealth": {
+    "noiseFloorWarning": -100,
+    "noiseFloorCritical": -85,
+    "spikeThresholdDb": 15,
+    "txDutyCycleWarning": 8,
+    "deafThresholdPct": 10,
+    "deafMinFleetSize": 5,
+    "offlineTimeoutSec": 900,
+    "sampleIntervalSec": 300,
+    "retentionDays": 30,
+    "errorRateWarning": 5,
+    "lowBatteryMv": 3300
+  }
+}
+```
+
+Note: No hardcoded duty cycle limit line on charts. Duty cycle regulations vary by jurisdiction (e.g., 1% in EU 868MHz, 10% in some US ISM bands). The warning threshold is configurable but no "regulatory limit" line is drawn on charts.
+
+## Implementation Milestones
+
+### M0: Prerequisite — Verify stats message frequency ✅ PASSED
+- **Confirmed 2026-04-05:** Live MQTT capture on staging shows status messages arriving every ~5 minutes per observer
+- **Fields confirmed present:** `noise_floor`, `tx_air_secs`, `rx_air_secs`, `recv_errors`, `battery_mv`, `uptime_secs`
+- **Fields NOT yet parsed by ingestor:** `tx_air_secs`, `rx_air_secs`, `recv_errors` (noise_floor and battery_mv already parsed)
+- **Ingestor timestamps:** Use ingestor wall clock, not observer timestamps (confirmed in design)
+- **Verified:** `triggerNoiseFloorCalibrate()` fires every 2 seconds (`NOISE_FLOOR_CALIB_INTERVAL = 2000ms` in `Dispatcher.cpp`). Continuous calibration with 64 RSSI samples per cycle. Noise floor data is always fresh.
+- **Gate: PASSED.** Proceed to M1.
+
+### M1: Store metrics + small multiples grid (MVP)
+- Create `observer_metrics` table with all columns (migration)
+- Ingestor: parse all available fields from stats, `INSERT OR REPLACE` with rounded timestamps
+- Handle missing fields gracefully (store NULLs)
+- Detect counter resets and record reboot events
+- Add `/api/observers/{id}/metrics` endpoint (all available fields)
+- Add `/api/observers/metrics/summary` endpoint (cached incrementally)
+- Add "RF Health" tab to Analytics
+- **Small multiples grid** with sparklines and inline values for all observers
+- Per-observer detail view: noise floor line chart with reference lines (not color bands), reboot markers as vertical hairlines, cold-start sample annotation
+- Time range selector (1h/3h/6h/12h/24h/3d/7d/30d + custom range picker)
+- Deep linking
+- Retention pruning
+- Tests: sampling, insertion idempotency, retention, API responses, gap handling, reboot detection
+
+### M2: Airtime + channel quality charts
+- Server-side delta computation for all cumulative counters with reboot handling and gap detection
+- Add `resolution` query param for downsampling (1h, 1d)
+- Airtime charts: two separate lines (TX/RX), directly labeled — not stacked area
+- Channel quality chart: recv_error_rate line + packets_recv step-line
+- Battery voltage chart (shown only when data exists)
+- All charts time-aligned, sharing X-axis, reboot markers spanning all charts
+- Tests: delta computation, reboot handling, counter reset, gap insertion, downsampling, error rate calculation
+
+#### M2 feedback improvements (post-M2)
+- **Auto-scale airtime Y-axis**: clamp to min/max of actual data values (20% headroom, min 1%) instead of fixed 0-100%, matching noise floor chart behavior. Increases data-ink ratio for low-activity nodes.
+- **Hover tooltips on all chart data points**: invisible SVG circles with `<title>` elements on every data point across all 4 charts (noise floor, airtime, error rate, battery). Shows exact value + UTC timestamp on hover. Detail-on-demand without cluttering the chart.
+
+### M3: Pattern detection
+- Implement after operators have used raw charts (M1–M2) and provided feedback
+- Jammer detection (NF spike + RX drop)
+- Digital interference detection (high recv_errors + stable NF)
+- Deaf receiver detection (with ≥5 fleet minimum)
+- Low battery detection
+- Interference trend detection
+- Status text indicators with priority ordering (no emoji badges — text only)
+- Baseline computation (rolling median excluding cold-start samples, cached)
+- Configurable alert thresholds
+- Tests: each pattern, edge cases, status priority
+
+### M4: Fleet comparison + advanced views
+- Fleet comparison as **small multiples** (one noise floor chart per observer, identical Y-scale) — not overlay
+- Sort/filter fleet by status, noise floor, error rate
+- Optional: per-observer historical baseline trend
+- Use 1h resolution for 7d views
+
+### M5: Metrics export — Prometheus / Grafana / external systems
+- **Prometheus endpoint:** `GET /metrics` exposing observer radio metrics in Prometheus exposition format
+  - Gauges per observer: `corescope_observer_noise_floor_dbm{observer="...",name="..."}`, `corescope_observer_tx_air_secs_total`, `corescope_observer_rx_air_secs_total`, `corescope_observer_recv_errors_total`, `corescope_observer_battery_mv`, `corescope_observer_uptime_secs`
+  - Fleet-level: `corescope_observers_total`, `corescope_observers_online`
+  - Packet counters: `corescope_packets_total`, `corescope_observations_total`
+  - Standard `process_*` and `go_*` runtime metrics via `promhttp` handler
+- **Configurable:** Enable/disable via `config.json` (`metrics.prometheusEnabled: true`, `metrics.prometheusPath: "/metrics"`)
+- **Auth:** Optional bearer token or basic auth on the metrics endpoint (prevents public scraping)
+- **Labels:** Each observer metric labeled with `observer` (pubkey), `name` (friendly name), `region`
+- **Why Prometheus format:** Industry standard, compatible with Grafana, Datadog, Victoria Metrics, Mimir, and any OpenMetrics consumer. Operators who already run monitoring stacks can integrate CoreScope without any custom work.
+- **Implementation:** Use Go `prometheus/client_golang` library. Register collectors that read from the in-memory `PacketStore` and `observer_metrics` table. No additional polling — just expose current state on each scrape.
+- **Grafana dashboard template:** Ship a JSON dashboard template (`docs/grafana-dashboard.json`) that operators can import for instant RF health visualization in Grafana. Pre-configured panels matching the built-in RF Health tab.
+- **OpenTelemetry (future):** If demand exists, add OTLP export alongside Prometheus. Not in M5 scope.
+
+## Design Decisions
+
+1. **Per-observer, not per-device.** Even if two observers share hardware, their RF environments may differ (different antennas, channels). observer_id is already the natural key.
+2. **Poll-on-tab-switch, not WebSocket push.** Data changes every 5 minutes. Users check this tab when investigating issues, not for live monitoring. WebSocket push adds complexity for no UX benefit.
+3. **SVG charts.** Matches existing analytics.js patterns. Canvas only if fleet comparison proves too slow with SVG.
+4. **Server-side deltas.** Keeps firmware details out of the frontend. Single point for reboot/gap handling logic.
+5. **Incremental fleet summary cache.** 7 inserts/min is trivially cheap to process. No need to query SQLite on every summary request.
+6. **No standalone timestamp index.** The composite PK handles all query patterns. A standalone index wastes write amplification.
+7. **Ingestor wall clock for timestamps.** Observer clocks are unreliable. Consistent time source prevents alignment issues.
+8. **Small multiples over accordion/cards.** Enables instant visual fleet comparison without clicking. Anomalies break the visual pattern of the grid. (Tufte: "Small multiples are the best design solution for a wide range of problems in data presentation.")
+9. **Reference lines, not color bands.** Color bands add non-data ink and pre-judge thresholds. Reference lines are minimal and informational.
+10. **Two lines, not stacked area for airtime.** Stacked areas make the upper series unreadable. Two lines with direct labels are always more honest.
+11. **Text status indicators, not emoji badges.** Emoji badges are decorative chrome. Plain text with semantic color (red/amber/default) is higher data-ink ratio and more accessible.
+12. **Reboot markers as cross-chart annotations.** Reboots affect all metrics simultaneously. Showing them as vertical hairlines across all charts prevents the operator from having to correlate events across separate views.
+13. **Separate packets_sent/packets_recv.** The ratio reveals asymmetric link problems invisible in a combined count.
+14. **recv_errors as a first-class metric.** CRC failures are the strongest channel quality signal — more diagnostic than noise floor alone for in-band interference.
+15. **Exclude cold-start samples from baseline.** First-post-reboot noise floor readings may reflect calibration artifacts, not the RF environment. Including them would bias the baseline.
+
+## Open Questions
+
+1. **Multiple observers on same channel:** If two observers share a channel, their noise floors should correlate. Could be useful for validation but doesn't change the data model.
+2. **EMA vs median for baseline:** Exponential moving average is cheaper (no sort) and smoother than median. Consider for M3 implementation — but median is more robust against outliers. Decision deferred to M3.
+3. **`triggerNoiseFloorCalibrate()` frequency:** Must be verified in M0. If it fires on every stats cycle, noise floor readings may be artificially smoothed. If only on boot, cold-start caveat applies. This affects how much weight to give noise floor vs. recv_errors for interference detection.
+4. **Battery voltage thresholds:** 3.3V is a reasonable default for LiPo cells, but varies by chemistry and regulator. May need per-observer configuration.

docs/specs/startup-performance.md

@@ -0,0 +1,212 @@
+# Startup Performance: Serve HTTP Within 2 Minutes on Any Database Size
+
+## Problem
+
+CoreScope takes 30–45 minutes to start on large databases (325K transmissions, 7.3M observations, 1.4GB SQLite). The HTTP server is completely unavailable during this time. Operators cannot restart without 30+ minutes of downtime.
+
+### Where time goes (7.3M observation benchmark)
+
+| Phase | Time | Blocking? |
+|---|---|---|
+| `Load()` — read SQLite → memory | ~90s | Yes |
+| Build subpath index | ~20s | Yes |
+| Build distance index | ~15s | Yes |
+| Build path-hop index | <1s | Yes |
+| Load neighbor edges from SQLite | <1s | Yes |
+| **Backfill `resolved_path` for NULL observations** | **20–30+ min** | **Yes — the killer** |
+| Re-pick best observations | ~10s | Yes |
+
+The backfill calls `resolvePathForObs` for every observation with `resolved_path IS NULL`, then writes results back to SQLite and updates in-memory state. On first run (or after schema migration), this means resolving all 7.3M observations.
+
+### Root cause
+
+`backfillResolvedPaths()` in `neighbor_persist.go` runs synchronously in `main()` before `httpServer.ListenAndServe()`. It:
+1. Collects all observations with `ResolvedPath == nil` under a read lock
+2. Resolves paths (CPU-bound, ~millions of calls to `resolvePathForObs`)
+3. Writes results to SQLite in a single transaction
+4. Updates in-memory state under a write lock
+
+Steps 2–4 block the main goroutine for 20–30 minutes.
+
+## Solution: Async Chunked Backfill
+
+### Design
+
+Move `backfillResolvedPaths` out of the startup critical path. Start the HTTP server immediately after loading data and building indexes. Run backfill in a background goroutine with chunked processing that yields between batches.
+
+### Startup sequence (new)
+
+```
+1. OpenDB, verify tables                    (~1s)
+2. store.Load()                             (~90s)
+3. ensureNeighborEdgesTable                  (<1s)
+4. ensureResolvedPathColumn                  (<1s)
+5. Load/build neighbor graph                 (<1s)
+6. Build subpath/distance/path-hop indexes   (~35s)
+7. pickBestObservation (with whatever        (~10s)
+   resolved_path data exists)
+8. *** START HTTP SERVER ***                 — serving at ~2min mark
+9. Background: backfillResolvedPaths         (20-30 min, non-blocking)
+   → chunked, yields between batches
+   → updates in-memory + SQLite incrementally
+   → re-picks best obs for affected txs
+```
+
+Total time to first HTTP response: **~2 minutes** regardless of database size.
+
+### Implementation details
+
+#### 1. Background backfill goroutine
+
+```go
+// In main(), after starting HTTP server:
+go func() {
+    backfillResolvedPathsAsync(store, dbPath, 5000, 100*time.Millisecond)
+}()
+```
+
+The async backfill processes observations in chunks of N (e.g., 5,000):
+
+```go
+func backfillResolvedPathsAsync(store *PacketStore, dbPath string, chunkSize int, yieldDuration time.Duration) {
+    for {
+        n := backfillResolvedPathsChunk(store, dbPath, chunkSize)
+        if n == 0 {
+            break // done
+        }
+        log.Printf("[store] backfilled resolved_path for %d observations (async)", n)
+        time.Sleep(yieldDuration) // yield to HTTP handlers
+    }
+    log.Printf("[store] async resolved_path backfill complete")
+}
+```
+
+Each chunk:
+1. Takes a read lock, collects up to `chunkSize` pending observations, releases lock
+2. Resolves paths (no lock held — `resolvePathForObs` only reads immutable data)
+3. Opens a separate RW SQLite connection, writes results in a transaction
+4. Takes a write lock, updates in-memory `obs.ResolvedPath` and re-picks best obs for affected transmissions, releases lock
+5. Sleeps briefly to yield CPU/lock time to HTTP handlers
+
+#### 2. Readiness flag and API degraded-mode header
+
+Add a boolean to `PacketStore`:
+
+```go
+type PacketStore struct {
+    // ...
+    backfillComplete atomic.Bool
+}
+```
+
+API responses include a header during backfill:
+
+```
+X-CoreScope-Status: backfilling
+X-CoreScope-Backfill-Remaining: 4523000
+```
+
+After backfill completes:
+```
+X-CoreScope-Status: ready
+```
+
+The frontend can read this header and show a subtle banner: *"Resolving hop paths… some paths may show abbreviated pubkeys."*
+
+#### 3. Index rebuilds
+
+The subpath, distance, and path-hop indexes are built during startup from whatever data exists. During backfill, newly resolved paths need to update these indexes incrementally.
+
+Options (in order of preference):
+
+**Option A: Defer index updates to end of backfill.** Indexes work fine with unresolved paths — they just produce slightly less precise results. After backfill completes, rebuild indexes once. Simple, correct, low risk.
+
+**Option B: Incremental index updates per chunk.** After each chunk, update affected index entries. More complex, better real-time accuracy. Only worth it if index accuracy during backfill matters for production use.
+
+**Recommendation: Option A.** The indexes are usable with unresolved paths. A single rebuild at the end (~35s) is cheap compared to the backfill duration. The API works throughout — results just improve after backfill finishes.
+
+#### 4. SQLite contention
+
+The backfill opens a separate RW connection for writes. The main server uses a read-only connection for polling. SQLite WAL mode (already in use) allows concurrent readers and one writer. Contention risk is minimal:
+
+- Write transactions are small (5,000 UPDATEs per chunk, batched in a single tx)
+- Read queries from HTTP handlers are unaffected by WAL writes
+- The 100ms yield between chunks prevents sustained write pressure
+
+#### 5. Lock contention
+
+The write lock is held only during the in-memory update phase of each chunk (~5,000 pointer assignments + re-picks). This takes microseconds. HTTP handlers acquire read locks for API responses — they will not be blocked for any perceptible duration.
+
+#### 6. Frontend handling
+
+The `hop-resolver.js` module already handles unresolved (prefix) hops gracefully — it shows abbreviated pubkeys. No frontend changes are required for correctness.
+
+Optional enhancement: read the `X-CoreScope-Status` header and show a transient info banner during backfill. This is cosmetic and can be done in a follow-up.
+
+### What about first-run specifically?
+
+On first run with a pre-existing database (e.g., migrating from a version without `resolved_path`), ALL 7.3M observations need backfill. The async approach handles this identically — it just takes longer in the background while HTTP is already serving.
+
+On subsequent restarts, `resolved_path` is already persisted in SQLite and loaded by `store.Load()`. The backfill loop finds zero pending observations and exits immediately.
+
+### What about new observations during backfill?
+
+The poller ingests new packets continuously. New observations written by the ingestor already have `resolved_path` set at ingest time (this is already implemented). The backfill only processes observations with `ResolvedPath == nil`, so there's no conflict with new data.
+
+## Alternatives considered
+
+### Lazy resolution (resolve on API access)
+
+Resolve `resolved_path` only when an observation is accessed via API, cache the result.
+
+**Rejected because:**
+- Adds latency to every API call that touches unresolved observations
+- Cache invalidation complexity (when does a cached resolution become stale?)
+- Doesn't help with index accuracy — indexes still need full data
+- The backfill is a one-time cost; lazy resolution makes it a recurring cost
+
+### Progressive loading (recent data first)
+
+Load only the last 24h into memory, start serving, load historical data in background.
+
+**Rejected because:**
+- Significantly more complex — all store operations need "is this data loaded yet?" checks
+- Memory implications: need to track which time ranges are loaded
+- Historical queries return wrong results during loading (not just degraded — wrong)
+- The actual bottleneck is backfill, not `Load()`. Even loading all 7.3M observations takes only ~90s.
+
+### Chunked blocking backfill (yield to HTTP between chunks, but keep in main startup)
+
+Process N observations per tick with `runtime.Gosched()` between chunks, but still in `main()` before `ListenAndServe`.
+
+**Rejected because:**
+- HTTP still isn't available until all chunks complete
+- Adds complexity without solving the core problem
+
+## Carmack Review (Performance)
+
+**The approach is sound.** Moving a 20–30 minute blocking operation to a background goroutine is the right call. Some notes:
+
+1. **Chunk size tuning.** 5,000 is a reasonable starting point. Monitor: if write lock contention shows up in pprof (unlikely with microsecond hold times), reduce chunk size. If backfill is too slow, increase it or reduce yield time.
+
+2. **Memory is not a concern.** The observations are already fully loaded in memory by `Load()`. The backfill only mutates the `ResolvedPath` field on existing objects — no additional memory allocation beyond temporary slices for the chunk.
+
+3. **No hidden costs in `resolvePathForObs`.** It reads `nodePM` (a `PrefixMatcher`, immutable after startup) and `graph` (neighbor graph, immutable after startup). No locks needed during resolution. This is embarrassingly parallelizable if needed, but single-goroutine processing with chunking is sufficient.
+
+4. **The index rebuild at the end is O(n) and takes ~35s.** This is a one-time cost after the first backfill. Not worth optimizing further unless the profile shows otherwise.
+
+5. **Risk: `pickBestObservation` during backfill.** API responses may flip their "best" observation as resolved paths become available. This is cosmetically noisy but functionally correct. Document this as expected behavior.
+
+6. **Future optimization if needed:** The backfill loop could be parallelized across multiple goroutines (partition observations by transmission hash). The resolution step is CPU-bound and read-only. This would reduce backfill wall time from 30 min to ~5 min on 8 cores. Not needed for MVP — the goal is HTTP availability, not backfill speed.
+
+## Implementation plan
+
+1. **Refactor `backfillResolvedPaths` into chunked async version** — new function `backfillResolvedPathsAsync` that processes in chunks and yields
+2. **Move backfill call in `main.go` to after `ListenAndServe`** — wrap in goroutine
+3. **Add `backfillComplete` atomic flag to `PacketStore`** — set after backfill finishes
+4. **Add `X-CoreScope-Status` response header** — middleware reads the flag
+5. **Rebuild indexes after backfill completes** — single call to rebuild subpath/distance/path-hop
+6. **Tests:** unit test for chunked backfill (mock store with N unresolved obs, verify chunks process correctly)
+7. **Frontend (follow-up):** optional banner during backfill state
+
+Estimated effort: 1–2 hours for steps 1–5, plus tests.

docs/specs/table-sorting.md

@@ -0,0 +1,144 @@
+# Table Sorting Consistency Spec (#620)
+
+## Problem
+
+CoreScope has 20+ data tables. Only 2 are sortable (nodes list, channel activity). Those 2 use incompatible implementations — different property names (`column`/`direction` vs `col`/`dir`), different data attributes (`data-sort` vs `data-sort-col`), different function signatures. The remaining 18+ tables, including the packets table (30K+ rows), have zero sorting.
+
+This violates AGENTS.md DRY rules and frustrates users who can see data but can't reorder it.
+
+## Solution
+
+One shared `TableSort` module. Every data table uses it. Same UX everywhere.
+
+## Shared Utility Design
+
+### Module: `public/table-sort.js`
+
+IIFE pattern (like `channel-colors.js`). No dependencies. No build step.
+
+```js
+window.TableSort = (function() {
+  return { init, sort, destroy };
+})();
+```
+
+### API
+
+```js
+TableSort.init(tableEl, {
+  defaultColumn: 'last_seen',     // initial sort column
+  defaultDirection: 'desc',       // 'asc' or 'desc'
+  storageKey: 'nodes-sort',       // localStorage key (optional)
+  comparators: {                  // custom comparators for non-string columns
+    time: (a, b) => ...,
+    snr:  (a, b) => ...,
+  },
+  onSort: (column, direction) => {} // callback after sort completes
+});
+```
+
+### How It Works
+
+1. Scans `<th>` elements for `data-sort="columnName"` attribute
+2. Attaches click handlers — click toggles asc/desc
+3. On sort: reads `<td data-value="...">` (raw sortable value) from each row
+4. Sorts rows in-place via DOM reorder (no innerHTML rebuild — important for 30K rows)
+5. Updates visual indicator and `aria-sort` on active `<th>`
+
+### Visual Indicator
+
+Active column header gets `▲` (ascending) or `▼` (descending) appended as a `<span class="sort-arrow">`. Inactive columns show no arrow. CSS class `.sort-active` on the active `<th>`.
+
+### Built-in Comparators
+
+| Type | Detected From | Behavior |
+|------|--------------|----------|
+| `numeric` | `data-type="number"` on `<th>` | `Number(a) - Number(b)`, NaN sorts last |
+| `text` | default | `localeCompare` |
+| `date` | `data-type="date"` | Parse as timestamp, numeric compare |
+| `dbm` | `data-type="dbm"` | Strip " dBm" suffix, numeric compare |
+
+Custom comparators in `options.comparators` override built-in types.
+
+### Accessibility
+
+- `aria-sort="ascending"`, `"descending"`, or `"none"` on every sortable `<th>`
+- `role="columnheader"` (already implicit for `<th>`)
+- `cursor: pointer` and `:hover` style on sortable headers
+- Keyboard: sortable headers are focusable, Enter/Space triggers sort
+
+### Performance (Critical for Packets Table)
+
+- Sort via DOM node reorder (`appendChild` loop), not `innerHTML`. Browser batches reflows.
+- `data-value` attributes hold raw values — no parsing during sort.
+- For 30K rows: expected sort time ~100-200ms (single `Array.sort` + DOM reorder). If >500ms, add a virtual scroll layer in a follow-up — but don't pre-optimize.
+- No re-render of row content. Sort only changes order.
+
+## Milestones
+
+### M1: Shared utility + packets table
+- Create `public/table-sort.js`
+- Unit tests: `test-table-sort.js` (Node.js, jsdom or vm.createContext)
+- Integrate with packets table (highest impact — 30K rows, currently unsortable)
+- Default sort: time descending
+- Columns: all current packets columns (Region, Time, Hash, Size, HB, Type, Observer, Path, Rpt, Details)
+- Browser validation: sort 30K rows, verify <500ms
+
+### M2: Nodes list + node detail tables
+- Migrate nodes list from custom sort to `TableSort.init()`
+- Add sorting to neighbor table (side pane + detail page)
+- Add sorting to observer stats table (detail page)
+- Remove old `sortState`/`sortArrow` code from `nodes.js`
+
+### M3: Analytics tables
+- Hash collisions tables (node table, sizes table, collision prefixes)
+- RF statistics table
+- Route frequency, co-appearance, topology tables
+- Node health tables (top by packets/SNR/observers, recently active)
+- Distance tables (by link type, top 20 longest)
+- Per-node analytics: peer contacts
+
+### M4: Channels list + observers list + comparison table
+- Channel activity table: migrate from custom sort to `TableSort.init()`
+- Remove old `_channelSortState` code from `analytics.js`
+- Observers list table
+- Comparison table (`compare.js`)
+
+### M5: Cleanup
+- Remove all old sorting code (both implementations)
+- Verify no dead CSS/JS from old sort code
+- Final consistency audit: every data table uses `TableSort.init()`
+
+### Out of Scope
+- `packets.js` hex breakdown (structural decode, fixed order)
+- `audio-lab.js` debug tables (not user-facing)
+- Virtual scroll / pagination (separate issue if perf requires it)
+
+## Testing
+
+### Unit Tests (`test-table-sort.js`)
+- Numeric sort ascending/descending
+- Text sort with localeCompare
+- Date sort
+- dBm sort (strip suffix)
+- Custom comparator override
+- NaN/null/undefined sort to end
+- Toggle direction on repeated click
+- `aria-sort` attribute updates
+- localStorage persistence (read + write)
+- `data-value` attribute used over text content
+
+### Integration (per milestone)
+- Playwright test: click column header, verify row order changes
+- Playwright test: click again, verify direction toggles
+- Playwright test: visual indicator present on active column
+
+### Performance
+- Unit test: sort 30K mock rows in <500ms (assert timing)
+- Required per AGENTS.md: perf claims need proof
+
+## Migration Path
+
+Existing sort code in `nodes.js` and `analytics.js` will be replaced, not wrapped. Both current implementations are <100 lines each — replacing is simpler than adapting. The shared utility subsumes all their functionality.
+
+Old localStorage keys (`nodes-sort-*`, channel sort state) should be migrated or cleared on first use of the new utility.

docs/specs/timestamp-filters.md

@@ -0,0 +1,266 @@
+# Timestamp-Based Packet Filters
+
+**Issue:** #289  
+**Status:** Draft  
+**Depends on:** #286 (timestamp display config)
+
+## Summary
+
+Extend the existing filter engine (`packet-filter.js`) with a `time` field type supporting absolute ISO timestamps, relative durations, and range expressions. The filter compiles date expressions to epoch milliseconds at parse time so per-packet evaluation is a single numeric comparison — no date parsing in the hot path.
+
+## Syntax
+
+### Absolute (ISO 8601)
+
+```
+time > "2024-01-01T00:00:00Z"
+time <= "2024-06-15"
+time == "2024-03-01"
+```
+
+Quoted strings after `time` are parsed as dates. Partial dates (`"2024-01-01"`) are treated as midnight UTC. All absolute values are interpreted as UTC regardless of the user's display preference.
+
+### Relative
+
+```
+time > 2h ago
+time > 30m ago
+time > 7d ago
+```
+
+The lexer recognizes `<number><unit> ago` as a relative time literal. Supported units: `s` (seconds), `m` (minutes), `h` (hours), `d` (days). At compile time, the relative offset is resolved to an absolute epoch ms value (`Date.now() - offset`). This means a compiled filter's relative thresholds are frozen at compile time — recompile to refresh.
+
+### Shorthand
+
+```
+time.ago < 30m
+time.ago < 2h
+```
+
+`time.ago` resolves to `Date.now() - packet.timestamp`. The comparison value is a duration literal (`30m`, `2h`, `7d`). This is syntactic sugar and semantically equivalent to the relative form but reads more naturally for "show me recent packets."
+
+### Range
+
+```
+time between "2024-01-01" "2024-01-02"
+time between 1h ago 30m ago
+```
+
+`between` is a ternary operator: `field between <low> <high>`. Compiles to `low <= field && field <= high`. Both bounds are inclusive.
+
+### Combinable with existing filters
+
+```
+type == Advert && time > 1h ago
+snr > 5 && time between "2024-01-01" "2024-01-02"
+(type == GRP_TXT || type == TXT_MSG) && time.ago < 30m
+```
+
+## Grammar Extension
+
+### New token types
+
+| Token | Pattern | Example |
+|-------|---------|---------|
+| `DURATION` | `/^\d+[smhd]$/` | `30m`, `2h`, `7d` |
+| `AGO` | keyword `ago` | `ago` |
+| `BETWEEN` | keyword `between` | `between` |
+
+### Lexer changes
+
+1. After reading an identifier that matches `\d+[smhd]`, emit `DURATION` token instead of `FIELD`.
+2. Recognize `ago` and `between` as keywords (like `and`/`or`).
+
+### Parser changes
+
+In `parseComparison()`:
+
+1. **Relative time:** If field is `time` and value tokens are `DURATION AGO`, compute `Date.now() - durationToMs(duration)` and store as a numeric epoch ms value in the AST node.
+2. **Absolute time:** If field is `time` and value is a `STRING`, attempt `new Date(value).getTime()`. If `NaN`, return parse error. Store epoch ms.
+3. **`time.ago` shorthand:** If field is `time.ago`, the value is a `DURATION`. Store the duration in ms. At evaluation, compute `now - packet_ts` and compare against the duration.
+4. **`between`:** If operator token is `BETWEEN`, consume two values (same type resolution as above). Emit `{ type: 'between', field, low, high }`.
+
+### AST node shapes
+
+```js
+// Absolute/relative (pre-resolved to epoch ms)
+{ type: 'comparison', field: 'time', op: '>', value: 1704067200000 }
+
+// time.ago (duration in ms)
+{ type: 'comparison', field: 'time.ago', op: '<', value: 1800000 }
+
+// between (both bounds as epoch ms)
+{ type: 'between', field: 'time', low: 1704067200000, high: 1704153600000 }
+```
+
+## Field Resolution
+
+Add to `resolveField()`:
+
+```js
+if (field === 'time') return packet.timestamp;  // epoch ms
+if (field === 'time.ago') return Date.now() - packet.timestamp;
+```
+
+`packet.timestamp` is the packet's capture time in epoch milliseconds. This field already exists in the data model (populated from the DB `created_at` column).
+
+## Time Semantics
+
+- **Filter expressions:** Always UTC. `"2024-01-01"` means `2024-01-01T00:00:00Z`.
+- **Display:** Follows the user's timestamp config from #286 (UTC/local/relative).
+- **Relative times:** Computed against `Date.now()` at compile time. The compiled filter is a snapshot — if the filter stays active for hours, relative thresholds drift. This is acceptable; filters are typically short-lived or recompiled on interaction.
+
+**No timezone specifiers in the filter syntax.** UTC only. This avoids ambiguity and parsing complexity. Users who think in local time can use the relative syntax (`time > 2h ago`) which is timezone-agnostic.
+
+## Performance
+
+### Compile-time work (once)
+
+- Parse date strings → epoch ms via `new Date().getTime()` (~1μs per date)
+- Parse duration strings → ms via multiplication (~0ns, trivial arithmetic)
+- Relative `ago` → `Date.now() - offset` (~0ns)
+
+### Per-packet evaluation (hot path)
+
+- `time` comparison: one numeric read + one numeric compare. Same cost as `snr > 5`.
+- `time.ago`: one subtraction + one compare. Two arithmetic ops. **Important:** cache `Date.now()` once per filter pass (e.g., in a closure variable set before iterating packets), not per-packet. 30K `Date.now()` calls are ~1ms but it's a pointless syscall tax.
+- `between`: two numeric compares.
+
+**No `Date` objects created per packet. No string parsing per packet. No regex per packet.**
+
+At 30K packets, the time filter adds ~0.1ms total to filter evaluation — dominated by the existing field resolution and AST walk overhead. No measurable regression.
+
+### Implementation note: `between` as sugar
+
+`between` should compile to `{ type: 'and', left: { type: 'comparison', field, op: '>=', value: low }, right: { type: 'comparison', field, op: '<=', value: high } }` — reusing existing comparison evaluation. No new AST node type, no new evaluator branch. The parser desugars it; the evaluator never sees `between`.
+
+### Implementation note: `time.ago` and `Date.now()` caching
+
+The `compile()` function should return a filter that accepts an optional `now` parameter:
+
+```js
+var compiled = compile('time.ago < 30m');
+var now = Date.now();
+packets.filter(function(p) { return compiled.filter(p, now); });
+```
+
+If `now` is not passed, `Date.now()` is called once on the first invocation and reused for the entire filter pass. This avoids 30K syscalls and ensures consistent evaluation within a single pass.
+
+## Carmack Review Notes
+
+Reviewed with a performance-first lens (30K+ packets, real-time updates):
+
+1. **✅ No allocations in hot path.** All date parsing happens at compile time. Per-packet evaluation is pure numeric comparison — same cost as existing `snr > 5` filters.
+
+2. **⚠️ `Date.now()` per-packet for `time.ago`.** Fixed above — cache once per filter pass via optional `now` parameter or closure. Without this, 30K packets × `Date.now()` = ~1ms wasted on a monotonic clock syscall that returns the same value.
+
+3. **✅ `between` as sugar, not a new node type.** Desugar in the parser to reuse existing `and` + `comparison` nodes. Zero new code paths in the evaluator = zero new bugs in the evaluator.
+
+4. **✅ Parser complexity is bounded.** Three new token types, one new keyword. The parser remains LL(1) — no backtracking, no ambiguity. `DURATION AGO` is a clear two-token lookahead only when field is `time`.
+
+5. **✅ Memory impact negligible.** Compiled time filters add one or two floats to the AST. At 16 bytes per node, even complex expressions with multiple time clauses are <100 bytes.
+
+6. **⚠️ Compiled filter staleness for relative times.** Spec acknowledges this. Acceptable for a web UI where filters are recompiled on user interaction. If filters persist across long WebSocket sessions, consider recompiling on a timer (every 60s). This is a future concern, not a blocker.
+
+7. **✅ No regex in hot path.** Duration parsing uses a simple char check on the last character + `parseInt`. Cheaper than any regex.
+
+A compiled time filter adds one or two 64-bit float values to the AST. Negligible — roughly 16 bytes per time comparison node.
+
+## URL Integration
+
+Time filters appear in the URL hash query string like any other filter:
+
+```
+#/packets?filter=time%20%3E%201h%20ago
+#/packets?filter=type%20%3D%3D%20Advert%20%26%26%20time%20%3E%20%222024-01-01%22
+```
+
+The filter text is URL-encoded and round-trips through `encodeURIComponent`/`decodeURIComponent`. No special handling needed — the existing filter-in-URL mechanism (#286 or current) works unchanged.
+
+For convenience, a future milestone could add dedicated `timeFrom`/`timeTo` query params that inject into the filter, but this is not required for the initial implementation.
+
+## Wireshark Compatibility
+
+| Wireshark syntax | CoreScope equivalent | Notes |
+|------------------|---------------------|-------|
+| `frame.time >= "2024-01-01"` | `time >= "2024-01-01"` | We use `time` instead of `frame.time` for brevity. Could alias `frame.time` → `time` later. |
+| `frame.time_relative < 60` | `time.ago < 60s` | Wireshark uses seconds float; we use duration literals |
+| `frame.time_delta` | Not supported | Inter-packet delta is a different feature |
+
+We intentionally diverge from Wireshark where their syntax is verbose or requires pcap-specific concepts. CoreScope's filter language prioritizes brevity and readability for a web UI. A `frame.time` alias for `time` can be added trivially in the field resolver if users request it.
+
+## Milestones
+
+### M1: Core time filtering (parser + evaluator)
+- Add `DURATION`, `AGO`, `BETWEEN` tokens to lexer
+- Extend parser for `time` field special handling
+- Add `time` and `time.ago` to `resolveField()`
+- Implement `between` AST node evaluation
+- Unit tests: absolute, relative, ago, between, combined with existing filters, edge cases (bad dates, invalid units)
+- **Test:** filter 30K packets by time in <50ms (assert in test)
+
+### M2: UI integration
+- Filter bar autocomplete hints for time syntax
+- Help tooltip / cheat sheet update with time examples
+- Verify URL round-trip with time filters
+- Playwright E2E test: enter time filter, verify packet list updates
+
+### M3: Polish
+- `frame.time` alias
+- Error messages for common mistakes ("did you mean `time > 1h ago`?")
+- Consider dedicated time range picker UI widget (out of scope for this spec)
+
+## Testing
+
+### Unit tests (add to `test-packet-filter.js`)
+
+```js
+// Absolute time
+c = compile('time > "2024-01-01"');
+assert(c.filter({ timestamp: new Date('2024-06-01').getTime() }), 'after 2024-01-01');
+assert(!c.filter({ timestamp: new Date('2023-06-01').getTime() }), 'before 2024-01-01');
+
+// Relative time
+c = compile('time > 1h ago');
+assert(c.filter({ timestamp: Date.now() - 30 * 60000 }), '30m ago passes 1h filter');
+assert(!c.filter({ timestamp: Date.now() - 2 * 3600000 }), '2h ago fails 1h filter');
+
+// time.ago shorthand
+c = compile('time.ago < 30m');
+assert(c.filter({ timestamp: Date.now() - 10 * 60000 }), '10m ago < 30m');
+assert(!c.filter({ timestamp: Date.now() - 60 * 60000 }), '60m ago not < 30m');
+
+// between
+c = compile('time between "2024-01-01" "2024-01-02"');
+assert(c.filter({ timestamp: new Date('2024-01-01T12:00:00Z').getTime() }), 'in range');
+assert(!c.filter({ timestamp: new Date('2024-01-03').getTime() }), 'out of range');
+
+// Combined
+c = compile('type == Advert && time > 1h ago');
+assert(c.filter({ payload_type: 4, timestamp: Date.now() - 1000 }), 'combined pass');
+assert(!c.filter({ payload_type: 4, timestamp: Date.now() - 7200000 }), 'combined fail time');
+assert(!c.filter({ payload_type: 1, timestamp: Date.now() - 1000 }), 'combined fail type');
+
+// Error cases
+c = compile('time > "not-a-date"');
+assert(c.error, 'invalid date string');
+
+c = compile('time > 5x ago');
+assert(c.error, 'invalid duration unit');
+
+// Performance
+var start = Date.now();
+c = compile('time > 1h ago && type == Advert');
+var packets = [];
+for (var i = 0; i < 30000; i++) {
+  packets.push({ payload_type: i % 5, timestamp: Date.now() - i * 1000 });
+}
+packets.forEach(function(p) { c.filter(p); });
+assert(Date.now() - start < 50, 'filter 30K packets in <50ms');
+```
+
+### Playwright tests
+
+- Enter `time > 1h ago` in filter bar → verify packet count decreases
+- Enter invalid time filter → verify error message appears
+- Reload page with time filter in URL → verify filter is applied

docs/superpowers/plans/2026-04-05-deep-linking-p1.md

@@ -0,0 +1,674 @@
+# Deep Linking P1 Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Make P1 UI states in nodes, packets, and channels URL-addressable so they survive refresh and can be shared.
+
+**Architecture:** Each page reads URL params from `location.hash.split('?')[1]` on init (router strips query string before passing `routeParam`, so pages must read `location.hash` directly). State changes call `history.replaceState` to keep the URL in sync. localStorage remains the fallback default; URL params override when present.
+
+**Tech Stack:** Vanilla JS (ES5/6), browser History API, URLSearchParams
+
+---
+
+## Files Changed
+
+| File | Changes |
+|---|---|
+| `public/region-filter.js` | Add `setSelected(codesArray)`, track `_container` for re-render |
+| `public/nodes.js` | Read `?tab=`/`?search=` on init; `updateNodesUrl()` on tab/search change; expose `buildNodesQuery` on `window` |
+| `public/packets.js` | Read `?timeWindow=`/`?region=` on init; `updatePacketsUrl()` on timeWindow/region change; expose `buildPacketsUrl` on `window` |
+| `public/channels.js` | Read `?node=` on init; update URL in `showNodeDetail`/`closeNodeDetail` |
+| `test-frontend-helpers.js` | Add unit tests for `buildNodesQuery` and `buildPacketsUrl` |
+| `test-e2e-playwright.js` | Add Playwright tests: tab URL persistence, timeWindow URL persistence |
+
+---
+
+## Task 1: Add `setSelected` to RegionFilter
+
+**Files:**
+- Modify: `public/region-filter.js`
+
+- [ ] **Step 1: Write the failing unit test**
+
+Add to `test-frontend-helpers.js` before the `// ===== SUMMARY =====` line:
+
+```javascript
+// ===== REGION-FILTER.JS: setSelected =====
+console.log('\n=== region-filter.js: setSelected ===');
+{
+  const ctx = makeSandbox();
+  ctx.fetch = () => Promise.resolve({ json: () => Promise.resolve({ 'US-SFO': 'San Jose', 'US-LAX': 'Los Angeles' }) });
+  loadInCtx(ctx, 'public/region-filter.js');
+
+  const RF = ctx.RegionFilter;
+  RF.init(document.createElement('div'));
+
+  test('setSelected sets region codes', async () => {
+    await RF.init(document.createElement('div'));
+    RF.setSelected(['US-SFO', 'US-LAX']);
+    assert.strictEqual(RF.getRegionParam(), 'US-SFO,US-LAX');
+  });
+
+  test('setSelected with null clears selection', async () => {
+    await RF.init(document.createElement('div'));
+    RF.setSelected(['US-SFO']);
+    RF.setSelected(null);
+    assert.strictEqual(RF.getRegionParam(), '');
+  });
+
+  test('setSelected with empty array clears selection', async () => {
+    await RF.init(document.createElement('div'));
+    RF.setSelected(['US-SFO']);
+    RF.setSelected([]);
+    assert.strictEqual(RF.getRegionParam(), '');
+  });
+}
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+```bash
+node test-frontend-helpers.js 2>&1 | grep -A2 "setSelected"
+```
+
+Expected: `❌ setSelected sets region codes: RF.setSelected is not a function`
+
+- [ ] **Step 3: Add `_container` tracking and `setSelected` to region-filter.js**
+
+In `region-filter.js`, add `var _container = null;` after the existing module-level vars (after line 9 `var _listeners = [];`):
+
+```javascript
+  var _listeners = [];
+  var _container = null;   // ← add this line
+  var _loaded = false;
+```
+
+In `initFilter`, save the container:
+
+```javascript
+  async function initFilter(container, opts) {
+    _container = container;          // ← add this line
+    if (opts && opts.dropdown) container._forceDropdown = true;
+    await fetchRegions();
+    render(container);
+  }
+```
+
+Add `setSelected` function before `// Expose globally`:
+
+```javascript
+  /** Override selected regions (e.g. from URL param). Persists to localStorage and re-renders. */
+  function setSelected(codesArray) {
+    _selected = (codesArray && codesArray.length > 0) ? new Set(codesArray) : null;
+    saveToStorage();
+    if (_container) render(_container);
+  }
+```
+
+Add `setSelected` to the public API object:
+
+```javascript
+  window.RegionFilter = {
+    init: initFilter,
+    render: render,
+    getSelected: getSelected,
+    getRegionParam: getRegionParam,
+    regionQueryString: regionQueryString,
+    onChange: onChange,
+    offChange: offChange,
+    fetchRegions: fetchRegions,
+    setSelected: setSelected,    // ← add this line
+  };
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+```bash
+node test-frontend-helpers.js 2>&1 | grep -E "(setSelected|FAIL|passed|failed)"
+```
+
+Expected: 3 passing `setSelected` tests, overall pass.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add public/region-filter.js test-frontend-helpers.js
+git commit -m "feat: add RegionFilter.setSelected for URL param initialization (#536)"
+```
+
+---
+
+## Task 2: nodes.js — tab and search deep linking
+
+**Files:**
+- Modify: `public/nodes.js`
+- Test: `test-frontend-helpers.js`
+- Test: `test-e2e-playwright.js`
+
+- [ ] **Step 1: Write the unit test (add to test-frontend-helpers.js)**
+
+Add before the `// ===== SUMMARY =====` line:
+
+```javascript
+// ===== NODES.JS: buildNodesQuery =====
+console.log('\n=== nodes.js: buildNodesQuery ===');
+{
+  const ctx = makeSandbox();
+  loadInCtx(ctx, 'public/roles.js');
+  loadInCtx(ctx, 'public/app.js');
+
+  // Provide required globals for nodes.js IIFE to execute
+  ctx.registerPage = () => {};
+  ctx.RegionFilter = { init: () => Promise.resolve(), onChange: () => () => {}, offChange: () => {}, getSelected: () => null, getRegionParam: () => '' };
+  ctx.onWS = () => {};
+  ctx.offWS = () => {};
+  ctx.debouncedOnWS = () => () => {};
+  ctx.invalidateApiCache = () => {};
+  ctx.favStar = () => '';
+  ctx.bindFavStars = () => {};
+  ctx.getFavorites = () => [];
+  ctx.isFavorite = () => false;
+  ctx.connectWS = () => {};
+  ctx.HopResolver = { init: () => {}, resolve: () => ({}), ready: () => false };
+  ctx.initTabBar = () => {};
+  ctx.debounce = (fn) => fn;
+  ctx.copyToClipboard = () => {};
+  ctx.api = () => Promise.resolve({});
+  ctx.escapeHtml = (s) => s;
+  ctx.timeAgo = () => '';
+  ctx.formatTimestampWithTooltip = () => '';
+  ctx.getTimestampMode = () => 'ago';
+  ctx.CLIENT_TTL = {};
+  ctx.qrcode = null;
+
+  try {
+    const src = fs.readFileSync('public/nodes.js', 'utf8');
+    vm.runInContext(src, ctx);
+    for (const k of Object.keys(ctx.window)) ctx[k] = ctx.window[k];
+  } catch (e) {
+    console.log('  ⚠️ nodes.js sandbox load failed:', e.message.slice(0, 120));
+  }
+
+  const buildNodesQuery = ctx.buildNodesQuery;
+
+  if (buildNodesQuery) {
+    test('buildNodesQuery: all tab + no search = empty', () => {
+      assert.strictEqual(buildNodesQuery('all', ''), '');
+    });
+    test('buildNodesQuery: repeater tab only', () => {
+      assert.strictEqual(buildNodesQuery('repeater', ''), '?tab=repeater');
+    });
+    test('buildNodesQuery: search only (all tab)', () => {
+      assert.strictEqual(buildNodesQuery('all', 'foo'), '?search=foo');
+    });
+    test('buildNodesQuery: tab + search combined', () => {
+      assert.strictEqual(buildNodesQuery('companion', 'bar'), '?tab=companion&search=bar');
+    });
+    test('buildNodesQuery: null search treated as empty', () => {
+      assert.strictEqual(buildNodesQuery('all', null), '');
+    });
+    test('buildNodesQuery: sensor tab', () => {
+      assert.strictEqual(buildNodesQuery('sensor', ''), '?tab=sensor');
+    });
+  } else {
+    console.log('  ⚠️ buildNodesQuery not exposed — skipping');
+  }
+}
+```
+
+- [ ] **Step 2: Run test to verify it fails (or skips)**
+
+```bash
+node test-frontend-helpers.js 2>&1 | grep -A3 "buildNodesQuery"
+```
+
+Expected: `⚠️ buildNodesQuery not exposed — skipping`
+
+- [ ] **Step 3: Add URL param reading and helpers to nodes.js**
+
+**3a.** Add `buildNodesQuery` and `updateNodesUrl` functions inside the nodes.js IIFE, after the `TABS` definition (around line 86, before `function renderNodeTimestampHtml`):
+
+```javascript
+  function buildNodesQuery(tab, searchStr) {
+    var parts = [];
+    if (tab && tab !== 'all') parts.push('tab=' + encodeURIComponent(tab));
+    if (searchStr) parts.push('search=' + encodeURIComponent(searchStr));
+    return parts.length ? '?' + parts.join('&') : '';
+  }
+  window.buildNodesQuery = buildNodesQuery;
+
+  function updateNodesUrl() {
+    history.replaceState(null, '', '#/nodes' + buildNodesQuery(activeTab, search));
+  }
+```
+
+**3b.** In the list-view branch of `init` (after the `return;` that ends the full-screen block at line 317), add URL param reading before `app.innerHTML`:
+
+```javascript
+    // Read URL params for list view (router strips query string from routeParam)
+    const _listUrlParams = new URLSearchParams(location.hash.split('?')[1] || '');
+    const _urlTab = _listUrlParams.get('tab');
+    const _urlSearch = _listUrlParams.get('search');
+    if (_urlTab && TABS.some(function(t) { return t.key === _urlTab; })) activeTab = _urlTab;
+    if (_urlSearch) search = _urlSearch;
+
+    app.innerHTML = `<div class="nodes-page">
+```
+
+**3c.** After `app.innerHTML = ...` (after the closing backtick at line ~330), populate the search input:
+
+```javascript
+    if (search) {
+      var _si = document.getElementById('nodeSearch');
+      if (_si) _si.value = search;
+    }
+```
+
+**3d.** In the search input event listener (around line 335), add `updateNodesUrl()`:
+
+```javascript
+    document.getElementById('nodeSearch').addEventListener('input', debounce(e => {
+      search = e.target.value;
+      updateNodesUrl();
+      loadNodes();
+    }, 250));
+```
+
+**3e.** In the tab click handler inside `renderLeft` (around line 875), add `updateNodesUrl()`:
+
+```javascript
+      btn.addEventListener('click', () => { activeTab = btn.dataset.tab; updateNodesUrl(); loadNodes(); });
+```
+
+- [ ] **Step 4: Run unit tests**
+
+```bash
+node test-frontend-helpers.js 2>&1 | grep -E "(buildNodesQuery|✅|❌)" | grep -v "helpers"
+```
+
+Expected: 6 passing `buildNodesQuery` tests.
+
+- [ ] **Step 5: Write Playwright test (add to test-e2e-playwright.js)**
+
+Add before the closing `await browser.close()` line:
+
+```javascript
+  // --- Group: Deep linking (#536) ---
+
+  // Test: nodes tab deep link
+  await test('Nodes tab deep link restores active tab', async () => {
+    await page.goto(BASE + '#/nodes?tab=repeater', { waitUntil: 'domcontentloaded' });
+    await page.waitForSelector('.node-tab', { timeout: 8000 });
+    const activeTab = await page.$('.node-tab.active');
+    assert(activeTab, 'No active tab found');
+    const tabText = await activeTab.textContent();
+    assert(tabText.includes('Repeater'), `Expected Repeater tab active, got: ${tabText}`);
+    const url = page.url();
+    assert(url.includes('tab=repeater'), `URL should contain tab=repeater, got: ${url}`);
+  });
+
+  // Test: nodes tab click updates URL
+  await test('Nodes tab click updates URL', async () => {
+    await page.goto(BASE + '#/nodes', { waitUntil: 'domcontentloaded' });
+    await page.waitForSelector('.node-tab', { timeout: 8000 });
+    const roomTab = await page.$('.node-tab[data-tab="room"]');
+    if (roomTab) {
+      await roomTab.click();
+      await page.waitForTimeout(300);
+      const url = page.url();
+      assert(url.includes('tab=room'), `URL should contain tab=room after click, got: ${url}`);
+    }
+  });
+```
+
+- [ ] **Step 6: Run full test suite**
+
+```bash
+node test-frontend-helpers.js
+```
+
+Expected: all tests pass.
+
+- [ ] **Step 7: Commit**
+
+```bash
+git add public/nodes.js test-frontend-helpers.js test-e2e-playwright.js
+git commit -m "feat: deep link nodes tab and search query (#536)"
+```
+
+---
+
+## Task 3: packets.js — timeWindow and region deep linking
+
+**Files:**
+- Modify: `public/packets.js`
+- Test: `test-frontend-helpers.js`
+- Test: `test-e2e-playwright.js`
+
+> Depends on Task 1 (RegionFilter.setSelected).
+
+- [ ] **Step 1: Write the unit test**
+
+Add to `test-frontend-helpers.js` before `// ===== SUMMARY =====`:
+
+```javascript
+// ===== PACKETS.JS: buildPacketsUrl =====
+console.log('\n=== packets.js: buildPacketsUrl ===');
+{
+  // Test the pure helper function
+  // (loaded via packets.js after it exposes window.buildPacketsUrl)
+  const ctx = makeSandbox();
+  loadInCtx(ctx, 'public/roles.js');
+  loadInCtx(ctx, 'public/app.js');
+
+  ctx.registerPage = () => {};
+  ctx.RegionFilter = { init: () => Promise.resolve(), onChange: () => () => {}, offChange: () => {}, getSelected: () => null, getRegionParam: () => '', setSelected: () => {} };
+  ctx.onWS = () => {};
+  ctx.offWS = () => {};
+  ctx.debouncedOnWS = () => () => {};
+  ctx.invalidateApiCache = () => {};
+  ctx.api = () => Promise.resolve({});
+  ctx.observerMap = new Map();
+  ctx.getParsedPath = () => [];
+  ctx.getParsedDecoded = () => ({});
+  ctx.clearParsedCache = () => {};
+  ctx.escapeHtml = (s) => s;
+  ctx.timeAgo = () => '';
+  ctx.formatTimestampWithTooltip = () => '';
+  ctx.getTimestampMode = () => 'ago';
+  ctx.copyToClipboard = () => {};
+  ctx.CLIENT_TTL = {};
+  ctx.debounce = (fn) => fn;
+  ctx.initTabBar = () => {};
+
+  try {
+    const src = fs.readFileSync('public/packet-helpers.js', 'utf8');
+    vm.runInContext(src, ctx);
+    for (const k of Object.keys(ctx.window)) ctx[k] = ctx.window[k];
+    const src2 = fs.readFileSync('public/packets.js', 'utf8');
+    vm.runInContext(src2, ctx);
+    for (const k of Object.keys(ctx.window)) ctx[k] = ctx.window[k];
+  } catch (e) {
+    console.log('  ⚠️ packets.js sandbox load failed:', e.message.slice(0, 120));
+  }
+
+  const buildPacketsUrl = ctx.buildPacketsUrl;
+
+  if (buildPacketsUrl) {
+    test('buildPacketsUrl: default (15min, no region) = bare #/packets', () => {
+      assert.strictEqual(buildPacketsUrl(15, ''), '#/packets');
+    });
+    test('buildPacketsUrl: non-default timeWindow', () => {
+      assert.strictEqual(buildPacketsUrl(60, ''), '#/packets?timeWindow=60');
+    });
+    test('buildPacketsUrl: region only', () => {
+      assert.strictEqual(buildPacketsUrl(15, 'US-SFO'), '#/packets?region=US-SFO');
+    });
+    test('buildPacketsUrl: timeWindow + region', () => {
+      assert.strictEqual(buildPacketsUrl(30, 'US-SFO,US-LAX'), '#/packets?timeWindow=30&region=US-SFO%2CUS-LAX');
+    });
+    test('buildPacketsUrl: timeWindow=0 treated as default', () => {
+      assert.strictEqual(buildPacketsUrl(0, ''), '#/packets');
+    });
+  } else {
+    console.log('  ⚠️ buildPacketsUrl not exposed — skipping');
+  }
+}
+```
+
+- [ ] **Step 2: Run to verify it skips**
+
+```bash
+node test-frontend-helpers.js 2>&1 | grep -A2 "buildPacketsUrl"
+```
+
+Expected: `⚠️ buildPacketsUrl not exposed — skipping`
+
+- [ ] **Step 3: Add helpers and URL param reading to packets.js**
+
+**3a.** Add `buildPacketsUrl` and `updatePacketsUrl` inside the packets.js IIFE, after the existing constants at the top (around line 36, after `let showHexHashes`):
+
+```javascript
+  function buildPacketsUrl(timeWindowMin, regionParam) {
+    var parts = [];
+    if (timeWindowMin && timeWindowMin !== 15) parts.push('timeWindow=' + timeWindowMin);
+    if (regionParam) parts.push('region=' + encodeURIComponent(regionParam));
+    return '#/packets' + (parts.length ? '?' + parts.join('&') : '');
+  }
+  window.buildPacketsUrl = buildPacketsUrl;
+
+  function updatePacketsUrl() {
+    history.replaceState(null, '', buildPacketsUrl(savedTimeWindowMin, RegionFilter.getRegionParam()));
+  }
+```
+
+**3b.** In the `init` function (around line 263), add URL param reading after the existing `routeParam`/`directObsId` parsing and before `app.innerHTML`:
+
+```javascript
+    // Read URL params for filter state (router strips query from routeParam; read from location.hash)
+    var _initUrlParams = new URLSearchParams(location.hash.split('?')[1] || '');
+    var _urlTimeWindow = Number(_initUrlParams.get('timeWindow'));
+    if (Number.isFinite(_urlTimeWindow) && _urlTimeWindow > 0) {
+      savedTimeWindowMin = _urlTimeWindow;
+      localStorage.setItem('meshcore-time-window', String(_urlTimeWindow));
+    }
+    var _urlRegion = _initUrlParams.get('region');
+    if (_urlRegion) {
+      RegionFilter.setSelected(_urlRegion.split(',').filter(Boolean));
+    }
+
+    app.innerHTML = `<div class="split-layout detail-collapsed">
+```
+
+**3c.** In the time window change handler (around line 865), add `updatePacketsUrl()`:
+
+```javascript
+    fTimeWindow.addEventListener('change', () => {
+      savedTimeWindowMin = Number(fTimeWindow.value);
+      if (!Number.isFinite(savedTimeWindowMin) || savedTimeWindowMin <= 0) savedTimeWindowMin = 15;
+      localStorage.setItem('meshcore-time-window', fTimeWindow.value);
+      updatePacketsUrl();
+      loadPackets();
+    });
+```
+
+**3d.** In the RegionFilter.onChange callback (around line 719), add `updatePacketsUrl()`:
+
+```javascript
+    RegionFilter.onChange(function() { updatePacketsUrl(); loadPackets(); });
+```
+
+- [ ] **Step 4: Run unit tests**
+
+```bash
+node test-frontend-helpers.js 2>&1 | grep -E "(buildPacketsUrl|✅|❌)" | grep -v "helpers"
+```
+
+Expected: 5 passing `buildPacketsUrl` tests.
+
+- [ ] **Step 5: Write Playwright test (add to test-e2e-playwright.js, inside the deep-linking group)**
+
+```javascript
+  // Test: packets timeWindow deep link
+  await test('Packets timeWindow deep link restores dropdown', async () => {
+    await page.goto(BASE + '#/packets?timeWindow=60', { waitUntil: 'domcontentloaded' });
+    await page.waitForSelector('#fTimeWindow', { timeout: 8000 });
+    const val = await page.$eval('#fTimeWindow', el => el.value);
+    assert(val === '60', `Expected timeWindow dropdown = 60, got: ${val}`);
+    const url = page.url();
+    assert(url.includes('timeWindow=60'), `URL should still contain timeWindow=60, got: ${url}`);
+  });
+
+  // Test: timeWindow change updates URL
+  await test('Packets timeWindow change updates URL', async () => {
+    await page.goto(BASE + '#/packets', { waitUntil: 'domcontentloaded' });
+    await page.waitForSelector('#fTimeWindow', { timeout: 8000 });
+    await page.selectOption('#fTimeWindow', '30');
+    await page.waitForTimeout(300);
+    const url = page.url();
+    assert(url.includes('timeWindow=30'), `URL should contain timeWindow=30 after change, got: ${url}`);
+  });
+```
+
+- [ ] **Step 6: Run full test suite**
+
+```bash
+node test-frontend-helpers.js
+```
+
+Expected: all tests pass.
+
+- [ ] **Step 7: Commit**
+
+```bash
+git add public/packets.js test-frontend-helpers.js test-e2e-playwright.js
+git commit -m "feat: deep link packets timeWindow and region filter (#536)"
+```
+
+---
+
+## Task 4: channels.js — node panel deep linking
+
+**Files:**
+- Modify: `public/channels.js`
+
+No unit tests needed for this task — the URL manipulation is side-effectful (DOM + History API). Playwright tests cover it.
+
+- [ ] **Step 1: Write the Playwright test (add to test-e2e-playwright.js, inside the deep-linking group)**
+
+```javascript
+  // Test: channels selected channel survives refresh (already implemented, verify it still works)
+  await test('Channels channel selection is URL-addressable', async () => {
+    await page.goto(BASE + '#/channels', { waitUntil: 'domcontentloaded' });
+    await page.waitForSelector('.ch-item', { timeout: 8000 }).catch(() => null);
+    const firstChannel = await page.$('.ch-item');
+    if (firstChannel) {
+      await firstChannel.click();
+      await page.waitForTimeout(500);
+      const url = page.url();
+      assert(url.includes('#/channels/') || url.includes('#/channels'), `URL should reflect channel selection, got: ${url}`);
+    }
+  });
+```
+
+- [ ] **Step 2: Update `showNodeDetail` to write `?node=` to the URL**
+
+In `channels.js`, in `showNodeDetail` (around line 171), add the URL update right after `selectedNode = name;`:
+
+```javascript
+  async function showNodeDetail(name) {
+    _nodePanelTrigger = document.activeElement;
+    if (_focusTrapCleanup) { _focusTrapCleanup(); _focusTrapCleanup = null; }
+    const node = await lookupNode(name);
+    selectedNode = name;
+    var _chBase = selectedHash ? '#/channels/' + encodeURIComponent(selectedHash) : '#/channels';
+    history.replaceState(null, '', _chBase + '?node=' + encodeURIComponent(name));
+
+    let panel = document.getElementById('chNodePanel');
+```
+
+- [ ] **Step 3: Update `closeNodeDetail` to strip `?node=` from the URL**
+
+In `closeNodeDetail` (around line 232), add URL restore right after `selectedNode = null;`:
+
+```javascript
+  function closeNodeDetail() {
+    if (_focusTrapCleanup) { _focusTrapCleanup(); _focusTrapCleanup = null; }
+    const panel = document.getElementById('chNodePanel');
+    if (panel) panel.classList.remove('open');
+    selectedNode = null;
+    var _chRestoreUrl = selectedHash ? '#/channels/' + encodeURIComponent(selectedHash) : '#/channels';
+    history.replaceState(null, '', _chRestoreUrl);
+    if (_nodePanelTrigger && typeof _nodePanelTrigger.focus === 'function') {
+```
+
+- [ ] **Step 4: Read `?node=` on init and auto-open panel**
+
+In `channels.js` `init` (line 316), add URL param reading at the very top of the function (before `app.innerHTML`):
+
+```javascript
+  function init(app, routeParam) {
+    var _initUrlParams = new URLSearchParams(location.hash.split('?')[1] || '');
+    var _pendingNode = _initUrlParams.get('node');
+
+    app.innerHTML = `<div class="ch-layout">
+```
+
+Then update the `loadChannels().then(...)` call (around line 350) to auto-open the node panel:
+
+```javascript
+    loadChannels().then(async function () {
+      if (routeParam) await selectChannel(routeParam);
+      if (_pendingNode) showNodeDetail(_pendingNode);
+    });
+```
+
+- [ ] **Step 5: Run full test suite**
+
+```bash
+node test-frontend-helpers.js
+```
+
+Expected: all tests pass (no channels unit tests, but regression tests still pass).
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add public/channels.js
+git commit -m "feat: deep link channels node panel via ?node= (#536)"
+```
+
+---
+
+## Task 5: Run E2E Playwright tests
+
+- [ ] **Step 1: Start the local server**
+
+```bash
+cd cmd/server && go run . &
+```
+
+Wait for it to be ready (check `http://localhost:3000`).
+
+- [ ] **Step 2: Run Playwright tests**
+
+```bash
+node test-e2e-playwright.js
+```
+
+Expected: all tests pass including the new deep-linking group.
+
+- [ ] **Step 3: If any deep-linking test fails, debug**
+
+Common failures:
+- Selector `.node-tab.active` not found: check that nodes.js correctly reads `?tab=` from URL before rendering
+- `#fTimeWindow` value wrong: check that `savedTimeWindowMin` is overridden before the DOM is built
+- URL doesn't update: check `history.replaceState` calls in the change handlers
+
+- [ ] **Step 4: Final commit (if any fixes needed)**
+
+```bash
+git add public/nodes.js public/packets.js public/channels.js
+git commit -m "fix: deep linking E2E adjustments (#536)"
+```
+
+---
+
+## Self-Review
+
+**Spec coverage check:**
+- ✅ P1: Nodes role tab → Task 2
+- ✅ P1: Packets time window → Task 3
+- ✅ P1: Packets region filter → Task 3 (depends on Task 1)
+- ✅ P1: Channels selected channel → Already implemented via `#/channels/{hash}` (verified in channels.js init line 351)
+- ✅ P1: Channels node panel → Task 4
+- ✅ P2+ items → explicitly out of scope per issue
+
+**Architecture note:** The router in `app.js` strips the query string at line 422 (`const route = hash.split('?')[0]`) before computing `basePage` and `routeParam`. Therefore `#/nodes?tab=repeater` gives `routeParam=null` (not `?tab=repeater`). All pages must read URL params from `location.hash` directly, not from `routeParam`. This is the established pattern in `analytics.js` and `nodes.js` (section scroll).
+
+**Placeholder scan:** No TBDs, no "implement later", all code blocks complete. ✅
+
+**Type consistency:**
+- `buildNodesQuery(tab, searchStr)` — used consistently in `updateNodesUrl()` and in tests ✅
+- `buildPacketsUrl(timeWindowMin, regionParam)` — used consistently in `updatePacketsUrl()` and in tests ✅
+- `RegionFilter.setSelected(codesArray)` — defined in Task 1, used in Task 3 ✅

docs/test-plans/v3.4.2-manual-validation.md

@@ -0,0 +1,162 @@
+# v3.4.2 Manual Validation Checklist
+
+**Tester:** _______________
+**Staging:** http://20.109.157.39
+**Prod:** https://analyzer.00id.net (READ ONLY — do not deploy until staging passes)
+**Browser:** Chrome + Firefox + Safari (mobile for responsive items)
+**Time estimate:** ~45 minutes
+
+---
+
+## 🔴 HIGH RISK — Test First
+
+### 1. Zero-hop hash size display (#649, #653)
+- [ ] Go to Packets page, find a DIRECT advert (route_type=2, 0 hops)
+- [ ] Open packet detail — hash size should say "Unknown (zero-hop)" or be hidden, NOT "1 byte"
+- [ ] Check "Path Length" field shows `hash_count=0 (direct advert)` 
+- [ ] Find a FLOOD advert with 0 hops — it SHOULD show hash size (this is different from DIRECT)
+
+### 2. TRACE packet real path (#651, #656)
+- [ ] Send a trace from your companion
+- [ ] Watch Live map — the animated dot should only travel along completed hops (solid line)
+- [ ] Unreached hops should show as dashed/ghosted line at reduced opacity
+- [ ] If trace completes fully, entire path should be solid
+- [ ] Ghost line should auto-clean after ~10 seconds
+
+### 3. "Paths through this node" accuracy (#655, #658)
+- [ ] Go to: http://20.109.157.39/#/nodes/c0dedad4208acb6cbe44b848943fc6d3c5d43cf38a21e48b43826a70862980e4
+- [ ] Check "Packets through this node" — packets should actually have this node in their path
+- [ ] Compare with a node that shares a 2-char prefix (e.g. C0ffee SF) — they should show DIFFERENT packets
+- [ ] Spot-check 3-4 packets: click through, verify path contains the node
+
+### 4. Hash Stats "By Repeaters" (#652, #654)
+- [ ] Go to Analytics → Hash Stats
+- [ ] "By Repeaters" section should only show repeater-role nodes
+- [ ] Compare count in "Multi-Byte Hash Adopters" vs "By Repeaters" — adopters may include companions, repeaters section should not
+- [ ] Check that companions/rooms/sensors are excluded from the repeater distribution
+
+### 5. Noise floor column chart (#600, #659)
+- [ ] Go to Analytics → RF Health
+- [ ] Noise floor chart should show vertical color-coded bars, NOT a line
+- [ ] Green bars (< -100 dBm), yellow (-100 to -85), red (≥ -85)
+- [ ] Hover over a bar — tooltip should show exact dBm + timestamp
+- [ ] Check with only 1 observer selected — chart should still render (division by zero edge case)
+- [ ] Reboot markers (if any) should show as vertical dashed lines
+
+### 6. Async backfill on startup
+- [ ] SSH to staging: `ssh -i ~/.ssh/id_ed25519 runner@20.109.157.39`
+- [ ] `docker restart corescope-staging-go`
+- [ ] Within 30 seconds, hit `curl http://localhost:82/api/stats` — should return data (not hang)
+- [ ] Check `backfilling` and `backfillProgress` fields in stats response
+- [ ] Server should be serving HTTP while backfill runs in background
+
+---
+
+## 🟡 MEDIUM RISK — Features
+
+### 7. Distance unit preference (#621, #646)
+- [ ] Go to Customizer → Display tab
+- [ ] Change distance unit to "mi" — all distances should show in miles
+- [ ] Change to "km" — all distances should show in km
+- [ ] Change to "auto" — should use locale (US = miles, EU = km)
+- [ ] Check Analytics page distances update after customizer change (no page reload needed)
+- [ ] Check Node detail → Neighbors table distances
+- [ ] Very small distances (<0.1 mi) should show in feet, not "0.0 mi"
+
+### 8. Panel corner toggle (#608, #657)
+- [ ] Go to Live map page
+- [ ] Each panel (feed, legend, node detail) should have a small corner-toggle button
+- [ ] Click the button — panel should snap to next corner (TL → TR → BR → BL)
+- [ ] Refresh page — panel positions should persist (localStorage)
+- [ ] Move two panels to same corner — collision avoidance should skip to next free corner
+- [ ] On mobile viewport (<768px?) — toggle buttons should be hidden
+
+### 9. Deep linking (#536, #618)
+- [ ] Navigate to Nodes page, click a node → URL should update with pubkey hash
+- [ ] Copy URL, open in new tab → should land on same node
+- [ ] Apply packet filters → URL hash should include filter params
+- [ ] Channels page: select a node → URL should reflect selection
+- [ ] Analytics tabs: switch tabs → URL should include tab name
+- [ ] Share a deep link with someone — they should see the same view
+
+### 10. Sortable tables (#620, #638, #639)
+- [ ] Nodes list: click column headers — should sort ascending/descending
+- [ ] Sort indicator (arrow) should be visible on active column
+- [ ] Node detail → Neighbors table: sortable
+- [ ] Node detail → Observers table: sortable
+- [ ] Packets table: sortable by column headers
+
+### 11. Channel color highlighting (#271, #607, #611)
+- [ ] Go to Channels page
+- [ ] Assign a color to a channel using the color picker
+- [ ] Feed rows should highlight with that color
+- [ ] Change color — should update immediately
+- [ ] Refresh — color assignment should persist
+
+### 12. Collapsible panels (#606)
+- [ ] Live map: panels should have collapse/expand toggle
+- [ ] Collapsed panel should show just the header
+- [ ] State should persist across page navigations
+
+### 13. Mobile accessibility (#630, #633)
+- [ ] Open staging on phone (or Chrome DevTools mobile emulation)
+- [ ] Touch targets should be at least 44×44px
+- [ ] Channel color picker should work on mobile
+- [ ] No horizontal scroll on any page
+- [ ] ARIA labels present on interactive elements (inspect with accessibility tools)
+
+### 14. Map byte-size filter (#565, #568)
+- [ ] Go to Map page
+- [ ] Find the byte-size filter control
+- [ ] Filter by packet size — map should update to show only matching packets
+- [ ] Clear filter — all packets should return
+
+### 15. API key security (#532, #628)
+- [ ] Try accessing a write endpoint without API key — should be blocked
+- [ ] Try with a weak key (e.g., "test", "admin") — should be rejected at startup
+- [ ] Check staging logs for API key warning: `docker logs corescope-staging-go 2>&1 | grep -i "apiKey\|api_key\|security"`
+
+### 16. OpenAPI/Swagger (#530, #632)
+- [ ] Hit http://20.109.157.39/api/spec — should return valid OpenAPI 3.0 spec
+- [ ] Hit http://20.109.157.39/api/docs — should show Swagger UI
+- [ ] Try an endpoint from Swagger UI — should work
+
+---
+
+## 🟢 LOW RISK — Verify Quickly
+
+### 17. View Route on Map button
+- [ ] Go to any packet detail page
+- [ ] Click "View Route on Map" — should navigate to map with route highlighted
+
+### 18. og-image compression
+- [ ] Check page source or network tab — og-image.png should be < 300KB (was 1.1MB)
+
+### 19. Prefix Tool
+- [ ] Analytics → Prefix Tool tab should load
+- [ ] Should show collision data
+
+### 20. License
+- [ ] Check repo footer/LICENSE — should be GPL v3
+
+### 21. Docker DISABLE_CADDY
+- [ ] (If testable) Set DISABLE_CADDY=true — Caddy should not start
+
+### 22. Region filter on RF Health
+- [ ] RF Health tab: change region filter — charts should update
+
+---
+
+## 🏁 Sign-off
+
+| Section | Status | Notes |
+|---------|--------|-------|
+| High risk (1-6) | ☐ | |
+| Medium risk (7-16) | ☐ | |
+| Low risk (17-22) | ☐ | |
+| **Overall** | ☐ | |
+
+**Tested by:** _______________  
+**Date:** _______________  
+**Staging version:** `curl -s http://20.109.157.39/api/stats | jq .version`  
+**Ready for release:** ☐ Yes / ☐ No — blockers: _______________

docs/test-plans/v3.4.2-release-test-plan.md

@@ -0,0 +1,309 @@
+# v3.4.2 Release Test Plan
+
+**Scope:** 90 commits since v3.4.1 (84 files, +14,931 / -1,005)  
+**Categories:** 19 perf, 19 feat, 18 fix, 15 docs, 3 chore, 1 test, 1 refactor, 1 ci  
+**Date:** 2026-04-08
+
+---
+
+## A. Automated Tests — Verify All Pass
+
+### Go Backend
+```bash
+cd cmd/server && go test -race -count=1 ./...
+cd cmd/ingestor && go test -race -count=1 ./...
+```
+
+**Test files (27 total):**
+
+| File | Tests For |
+|------|-----------|
+| `cmd/server/decoder_test.go` | Hash size zero-hop, TRACE hopsCompleted, transport direct |
+| `cmd/server/backfill_async_test.go` | **NEW** — Async chunked backfill |
+| `cmd/server/eviction_test.go` | Memory eviction with runtime heap stats |
+| `cmd/server/apikey_security_test.go` | **NEW** — Weak/default API key rejection |
+| `cmd/server/openapi_test.go` | **NEW** — OpenAPI spec generation |
+| `cmd/server/routes_test.go` | Batch observations endpoint, subpaths-bulk, expand=observations |
+| `cmd/server/cache_invalidation_test.go` | cacheTTL config wiring |
+| `cmd/server/config_knobs_test.go` | cacheTTLSec helper |
+| `cmd/server/helpers_test.go` | constantTimeEqual, IsWeakAPIKey |
+| `cmd/server/obs_dedup_test.go` | UniqueObserverCount tracking |
+| `cmd/server/neighbor_*.go` (4 files) | Neighbor graph, affinity, persistence |
+| `cmd/server/perfstats_race_test.go` | Perf stats concurrency |
+| `cmd/server/resolve_context_test.go` | Resolved path filtering |
+| `cmd/server/advert_pubkey_test.go` | Advert pubkey tracking |
+| `cmd/server/db_test.go` | SQLite operations |
+| `cmd/server/config_test.go` | Config loading |
+| `cmd/server/coverage_test.go` | Coverage helpers |
+| `cmd/server/parity_test.go` | Go/JS decoder parity |
+| `cmd/server/websocket_test.go` | WebSocket broadcast |
+| `cmd/ingestor/decoder_test.go` | Ingestor decoder (hash size zero-hop) |
+| `cmd/ingestor/db_test.go` | Ingestor DB writes |
+| `cmd/ingestor/config_test.go` | Ingestor config |
+| `cmd/ingestor/main_test.go` | Ingestor entry |
+| `cmd/ingestor/coverage_boost_test.go` | Coverage helpers |
+
+### Frontend Unit Tests
+```bash
+node test-packet-filter.js
+node test-aging.js
+node test-frontend-helpers.js
+node test-table-sort.js          # NEW — shared table sort utility
+node test-channel-colors.js      # NEW — channel color model
+node test-panel-corner.js        # NEW — panel corner toggle
+node test-packets.js             # NEW — packets page logic
+node test-hop-resolver-affinity.js
+node test-customizer-v2.js
+node test-live.js
+node test-live-dedup.js
+```
+
+### E2E / Playwright
+```bash
+BASE_URL=http://localhost:13581 node test-e2e-playwright.js
+```
+
+**Expected:** All existing tests pass + new tests added for sortable tables, deep linking, collapsible panels.
+
+---
+
+## B. Manual Browser Verification
+
+### B1. HIGH RISK — Data Correctness
+
+| # | Feature | Page | What to Check |
+|---|---------|------|---------------|
+| 1 | Hash size zero-hop | Packets detail | Find a direct (route_type=0) packet → hash_size should show 0, not a bogus computed value |
+| 2 | TRACE hopsCompleted | Packets detail / Live map | Find a TRACE packet → verify `hopsCompleted` shows in decoded JSON, live map shows real path length vs intended |
+| 3 | Transport direct hash size | Packets detail | Find route_type=RouteTransportDirect packet → hash_size=0 |
+| 4 | resolved_path filtering | Node detail → Paths tab | Verify path-hop candidates use resolved_path, no prefix collision false positives |
+| 5 | Hash stats repeater filter | Analytics → Hash Issues | "By Repeaters" should only show nodes with repeater role, not companions/sensors |
+| 6 | Async chunked backfill | Server startup | Start server with large DB → verify HTTP serves within 2 minutes, `X-CoreScope-Status: backfilling` header present, then transitions to `ready` |
+| 7 | Memory eviction (heap stats) | Admin/stats | Verify `/api/stats` shows realistic memory numbers from runtime heap, not the old estimation |
+| 8 | Distance/subpath/path-hop indexes | Analytics → Distances, Subpaths | Verify analytics data matches v3.4.1 output (no missing or extra entries) |
+| 9 | cacheTTL config wiring | Config | Set `cacheTTL.analyticsHashSizes: 300` in config → verify collision cache respects it |
+
+### B2. MEDIUM RISK — User-Facing Features
+
+| # | Feature | Page | What to Check |
+|---|---------|------|---------------|
+| 10 | Distance unit preference | Nodes detail, Map | Toggle km/mi/auto in settings → distances update throughout UI |
+| 11 | Panel corner toggle | Live page | Click corner toggle → panel moves to opposite corner, persists on reload |
+| 12 | Noise floor column chart | Analytics → RF | Verify column chart renders with color-coded thresholds, hover shows values |
+| 13 | Deep linking UI states | All pages | Navigate to `#/nodes?tab=neighbors`, `#/packets?observer=X`, `#/channels?node=Y` → correct state loads. Copy URL, open in new tab → same state |
+| 14 | Sortable tables | Nodes list, Neighbors, Observers | Click column headers → sort asc/desc, indicator arrow shows, persists correctly |
+| 15 | Channel color highlighting | Channels, Live feed | Assign color to channel → feed rows show that color, persists on reload |
+| 16 | Mobile accessibility | All pages (phone viewport) | Touch targets ≥44px, ARIA labels present, small viewport doesn't overflow |
+| 17 | Collapsible panels | Live map | Collapse/expand panels, medium breakpoint auto-collapses, state persists |
+| 18 | Byte-size map filter | Map page | Filter by byte size → markers update correctly |
+| 19 | OpenAPI/Swagger | `/api/spec`, `/api/docs` | Spec loads valid JSON, Swagger UI renders and all endpoints are documented |
+| 20 | API key rejection | Protected endpoints | Send weak key (e.g. "changeme", "test123") → 403 forbidden |
+| 21 | Channel color picker mobile | Channels (phone viewport) | Color picker usable on touch, doesn't overflow |
+| 22 | RF Health dashboard | Analytics → RF Health | Observer metrics grid, airtime charts, battery charts, error rate, region filter |
+| 23 | Prefix Tool tab | Analytics → Prefix Tool | Renders correctly, collision data consistent with Hash Issues |
+| 24 | View Route on Map | Packet detail page | Button works and shows route on map |
+
+### B3. LOWER RISK — Performance (Verify No Regressions)
+
+| # | Feature | Page | What to Check |
+|---|---------|------|---------------|
+| 25 | Incremental DOM diff | Packets (30K+) | Virtual scroll renders smoothly, no visible flicker |
+| 26 | Coalesced WS renders | Live page | Rapid packets don't cause frame drops (rAF coalescing) |
+| 27 | Marker reposition on zoom | Map | Zoom/resize → markers move smoothly, no full rebuild flash |
+| 28 | Parallel replay fetches | Live → VCR | Replay loads quickly (parallel observation fetches) |
+| 29 | Batch observations API | Packets page (sort change) | Changing sort fetches observations in batch (network tab: 1 POST not N GETs) |
+| 30 | Client-side network status | Analytics | No separate API call for network status |
+| 31 | og-image compression | `/og-image.png` | Verify loads, ~235KB not ~1.1MB |
+
+---
+
+## C. API Regression Tests
+
+Run against a local server with test-fixture DB:
+
+```bash
+BASE=http://localhost:13581
+
+# Core endpoints — verify response shape
+curl -s "$BASE/api/stats" | jq '.totalPackets, .backfilling, .backfillProgress'
+curl -s "$BASE/api/packets?limit=5" | jq '.packets[0] | keys'
+curl -s "$BASE/api/packets?limit=5&expand=observations" | jq '.packets[0].observations | length'
+curl -s "$BASE/api/nodes?limit=5" | jq '.[0] | keys'
+
+# New endpoints
+curl -s -X POST "$BASE/api/packets/observations" \
+  -H 'Content-Type: application/json' \
+  -d '{"hashes":["test123"]}' | jq '.results | keys'
+
+curl -s "$BASE/api/analytics/subpaths-bulk?hops=A,B&hops=B,C" | jq 'keys'
+
+curl -s "$BASE/api/observers/metrics/summary" | jq 'type'
+curl -s "$BASE/api/spec" | jq '.openapi'
+curl -s "$BASE/api/docs" | head -5  # Should return HTML
+
+# Backfill status header
+curl -sI "$BASE/api/stats" | grep X-CoreScope-Status
+
+# API key rejection
+curl -s -H 'X-API-Key: changeme' "$BASE/api/debug/vars" | jq '.error'
+curl -s -H 'X-API-Key: test' "$BASE/api/debug/vars" | jq '.error'
+
+# Existing endpoints — verify not broken
+curl -s "$BASE/api/analytics/rf?timeRange=24h" | jq 'keys'
+curl -s "$BASE/api/analytics/hash-sizes" | jq 'type'
+curl -s "$BASE/api/analytics/distances" | jq 'type'
+curl -s "$BASE/api/analytics/subpaths" | jq 'type'
+curl -s "$BASE/api/channels" | jq 'type'
+curl -s "$BASE/api/config/client" | jq 'keys'
+```
+
+### Expected response shape changes from v3.4.1:
+- `/api/stats` now includes `backfilling` (bool) and `backfillProgress` (float 0-1)
+- `/api/packets` no longer strips observations by default (lazy via `ExpandObservations` flag) — verify `observations` key absent without `expand=observations`
+- Decoded packets with route_type=direct now have `hashSize: 0`
+- TRACE packets now have `path.hopsCompleted` field
+
+---
+
+## D. Performance Regression Tests
+
+### D1. Server Startup Time
+```bash
+# Start server with production-size DB (~30K packets)
+# Measure time from process start to first successful HTTP response
+time curl -s http://localhost:13581/api/stats > /dev/null
+# Target: < 2 minutes (async backfill requirement)
+```
+
+### D2. Go Benchmarks
+```bash
+cd cmd/server && go test -bench=. -benchmem -count=3
+```
+Key benchmarks to compare with v3.4.1 baseline:
+- `BenchmarkQueryPackets` — should not regress with new indexes
+- `BenchmarkEvictStale` — batch removal from secondary indexes
+- `BenchmarkGetStoreStats` — 2 concurrent queries vs 5 sequential
+- `BenchmarkIngestNew` — additional index maintenance overhead
+
+### D3. Frontend Performance
+- Open Packets page with 30K+ packets → measure initial render time (DevTools Performance tab)
+- Scroll rapidly through virtual scroll → should maintain 60fps
+- Switch sort column on packets → single batch POST, not N+1 GETs
+- Open Analytics page → no redundant API calls in network tab
+
+### D4. Memory Usage
+- After loading 30K packets, check `/api/stats` memory figure
+- Compare with v3.4.1 baseline (prefix map cap at 8 chars should reduce ~10x)
+- Verify eviction triggers at correct memory threshold using runtime heap stats
+
+---
+
+## E. Infrastructure / Deployment Tests
+
+### E1. Docker Build
+```bash
+docker build -t corescope:test .
+docker run --rm -p 13581:13581 corescope:test
+# Verify: container starts, HTTP responds, WebSocket connects
+```
+
+### E2. GHCR Publish (CI)
+- Verify CI publishes to `ghcr.io/kpa-clawbot/corescope`
+- Verify tags: `edge` (master), `vX.Y.Z` (release)
+
+### E3. Staging Deploy
+```bash
+# Verify staging compose works with standard ports
+docker compose -f docker-compose.staging.yml up -d
+# Check: no 3GB memory limit, standard port binding
+```
+
+### E4. DISABLE_CADDY
+```bash
+docker run --rm -e DISABLE_CADDY=true corescope:test
+# Verify: Caddy not started, Go server serves directly
+```
+
+### E5. CI Pipeline
+- Verify consolidated pipeline: build → publish GHCR → deploy staging
+- Verify runs on `meshcore-runner-2`
+
+---
+
+## F. Edge Cases & Integration Tests
+
+### F1. Cross-Feature Interactions
+| Scenario | Risk |
+|----------|------|
+| Deep link to sorted table → sort state matches URL params | Medium |
+| Channel color + deep link → color persists in linked URL | Medium |
+| Panel corner toggle + collapsible panels → both states persist independently | Low |
+| Distance unit pref + neighbor table sort by distance → sort uses correct unit | Medium |
+| Noise floor chart + region filter → chart respects filter | Medium |
+| Byte-size map filter + channel color highlighting → both active simultaneously | Low |
+
+### F2. Data Correctness Edge Cases
+| Scenario | Risk |
+|----------|------|
+| Zero-hop TRACE packet (should NOT reset hashSize — TRACE exemption) | **High** |
+| Packet with all hops having same 2-char prefix → resolved_path filtering prevents false match | **High** |
+| Node that switches role (repeater → companion) → hash stats updates | Medium |
+| Backfill interrupted mid-chunk (server restart) → resumes or completes on next start | Medium |
+| Empty DB startup → no errors, backfill completes instantly | Low |
+| DB with 100K+ packets → async backfill doesn't OOM, progress reported | **High** |
+
+### F3. Concurrency / Race Conditions
+| Scenario | Risk |
+|----------|------|
+| Concurrent API requests during backfill → no deadlock (lock ordering documented) | **High** |
+| Eviction running while analytics query in progress → no stale pointer panic | **High** |
+| Multiple WebSocket clients during high ingest rate → coalesced broadcasts don't drop | Medium |
+| `time.NewTicker` cleanup on graceful shutdown (replaced `time.Tick`) | Low |
+
+### F4. API Key Security
+| Scenario | Expected |
+|----------|----------|
+| No API key configured → write endpoints disabled | 403 "write endpoints disabled" |
+| Weak key "changeme" → rejected even if configured | 403 "forbidden" |
+| Timing-safe comparison → no timing oracle | Constant-time via `crypto/subtle` |
+| Empty string key → rejected | 401 "unauthorized" |
+
+### F5. Browser Compatibility
+- Test on Chrome, Firefox, Safari (latest)
+- Test on iOS Safari, Android Chrome
+- Verify touch targets on mobile (44px minimum)
+- Verify ARIA labels with screen reader
+
+---
+
+## G. Test Coverage Gaps — Action Items
+
+| Gap | Priority | Action |
+|-----|----------|--------|
+| No automated test for distance unit preference rendering | Medium | Add Playwright test |
+| No automated test for noise floor column chart | Medium | Add Playwright test |
+| No automated test for deep link state restoration | **High** | Add Playwright tests for each deep-linkable state |
+| No automated test for channel color persistence | Medium | `test-channel-colors.js` covers model; need Playwright for UI |
+| No automated test for mobile viewport behavior | Medium | Add Playwright test with mobile viewport |
+| No automated test for backfill progress header | Low | Add to `routes_test.go` |
+| No automated test for `time.NewTicker` cleanup | Low | Add to graceful shutdown test |
+| Observer metrics endpoints not covered in route tests | Medium | Add to `routes_test.go` |
+| Subpaths-bulk endpoint needs test | Medium | Add to `routes_test.go` |
+| No load test for batch observations endpoint (200 hash limit) | Low | Add boundary test |
+
+---
+
+## H. Release Checklist
+
+- [ ] All Go tests pass with `-race` flag
+- [ ] All frontend unit tests pass
+- [ ] Playwright E2E tests pass
+- [ ] Manual browser verification (Section B) complete
+- [ ] API regression tests (Section C) pass
+- [ ] Docker build succeeds
+- [ ] Staging deploy verified
+- [ ] No console errors on any page
+- [ ] Performance spot-checks (Section D) — no regressions
+- [ ] Coverage badges updated (backend ≥85%, frontend ≥42%)
+- [ ] CHANGELOG updated
+- [ ] Tag `v3.4.2` created

docs/user-guide/analytics.md

@@ -0,0 +1,88 @@
+# Analytics
+
+The Analytics page provides deep-dive charts and tables about your mesh network. Select a tab to explore different aspects.
+
+[Screenshot: analytics page with tab bar]
+
+## Overview
+
+Summary dashboard with key network metrics at a glance. Quick sparklines and counts across all data dimensions.
+
+## RF / Signal
+
+Radio frequency analysis:
+
+- **SNR distribution** — histogram of signal-to-noise ratios across all packets
+- **RSSI distribution** — histogram of received signal strength
+- **SNR by observer** — which observers are getting the best signals
+- **Signal trends** — how signal quality changes over time
+
+Use this to identify weak links or noisy observers.
+
+## Topology
+
+Network structure analysis:
+
+- **Hop count distribution** — how many relay hops packets typically take
+- **Top relay nodes** — which repeaters handle the most traffic
+- **Node connectivity** — how well-connected each node is
+
+## Channels
+
+Channel message statistics:
+
+- **Messages per channel** — which channels are most active
+- **Channel activity over time** — traffic trends by channel
+- **Top senders** — most active nodes per channel
+
+## Hash Stats
+
+Mesh hash size analysis:
+
+- **Hash size distribution** — how many bytes nodes use for addressing
+- **Hash sizes by role** — do repeaters use different hash sizes than companions?
+
+## Hash Issues
+
+Potential hash collision detection:
+
+- **Collision pairs** — nodes whose short hash prefixes overlap
+- **Risk assessment** — how likely collisions are at current hash sizes
+
+Hash collisions can cause packet misrouting. If you see collisions here, consider increasing hash sizes on affected nodes.
+
+## Route Patterns (Subpaths)
+
+Common routing paths through the mesh:
+
+- **Frequent subpaths** — which relay chains appear most often
+- **Path reliability** — how consistently each path is used
+- **Path detail** — click a subpath to see every packet that used it
+
+## Nodes
+
+Per-node analytics with sortable metrics across the fleet.
+
+## Distance
+
+Estimated distances between nodes based on GPS coordinates, correlated with signal quality.
+
+## Neighbor Graph
+
+Interactive visualization of which nodes can directly hear each other. Shows the mesh topology as a network graph.
+
+## RF Health
+
+Per-observer signal health over time. Identifies observers with degrading reception.
+
+## Prefix Tool
+
+Test hash prefix lengths to see how many collisions different sizes would produce. Useful for deciding on hash_size settings.
+
+## Region filter
+
+All analytics tabs respect the **region filter** at the top. Select a region to scope the data to observers in that area.
+
+## Deep linking
+
+Each tab is deep-linkable. Share a URL like `#/analytics?tab=collisions` to point someone directly at hash issues.

docs/user-guide/channels.md

@@ -0,0 +1,68 @@
+# Channels
+
+The Channels page shows decrypted MeshCore channel messages — like a group chat viewer for your mesh.
+
+[Screenshot: channels page with message list]
+
+## What are channels?
+
+MeshCore nodes can send messages on named channels (like `#LongFast` or `#test`). These are group messages broadcast through the mesh. Any observer that hears the packet captures it.
+
+CoreScope can decrypt and display these messages if you provide the channel encryption key.
+
+## How it works
+
+1. Observers capture encrypted channel packets from the mesh
+2. CoreScope matches the packet's channel hash to a known channel name
+3. If a decryption key is configured, the message content is decrypted and displayed
+4. Without a key, you'll see the packet metadata but not the message text
+
+## Viewing messages
+
+Select a channel from the list on the left. Messages appear in chronological order on the right.
+
+Each message shows:
+- **Sender** — node name or hash
+- **Text** — decrypted message content
+- **Observer** — which observer captured it
+- **Time** — when it was received
+
+The message list auto-scrolls to show new messages as they arrive via WebSocket.
+
+## Channel keys
+
+To decrypt messages, add channel keys to your `config.json`:
+
+```json
+{
+  "channelKeys": {
+    "public": "8b3387e9c5cdea6ac9e5edbaa115cd72"
+  }
+}
+```
+
+The key name (e.g., `"public"`) is a label for your reference. The value is the 16-byte hex encryption key for that channel.
+
+See [Configuration](configuration.md) for details on `channelKeys` and `hashChannels`.
+
+## Hash channels
+
+The `hashChannels` config lists channel names that CoreScope should try to match by hash:
+
+```json
+{
+  "hashChannels": ["#LongFast", "#test", "#sf"]
+}
+```
+
+CoreScope computes the hash of each name and matches incoming packets to identify which channel they belong to.
+
+## Region filter
+
+Channels respect the region filter. Select a region to see only messages captured by observers in that area.
+
+## Tips
+
+- The default MeshCore "public" channel key is well-known — most community meshes use it
+- If messages appear but show garbled text, your key may be wrong
+- Not all packets are channel messages — only type "Channel Msg" (GRP_TXT) appears here

docs/user-guide/configuration.md

@@ -0,0 +1,181 @@
+# Configuration
+
+CoreScope is configured via `config.json` in the server's working directory. Copy `config.example.json` to get started.
+
+## Core settings
+
+| Field | Default | Description |
+|-------|---------|-------------|
+| `port` | `3000` | HTTP server port |
+| `apiKey` | — | Secret key for admin API endpoints (POST/PUT routes) |
+| `dbPath` | — | Path to SQLite database file (optional, defaults to `meshcore.db`) |
+
+## MQTT
+
+```json
+"mqtt": {
+  "broker": "mqtt://localhost:1883",
+  "topic": "meshcore/+/+/packets"
+}
+```
+
+The ingestor connects to this MQTT broker and subscribes to the topic pattern.
+
+### Multiple MQTT sources
+
+Use `mqttSources` for multiple brokers:
+
+```json
+"mqttSources": [
+  {
+    "name": "local",
+    "broker": "mqtt://localhost:1883",
+    "topics": ["meshcore/#"]
+  },
+  {
+    "name": "remote",
+    "broker": "mqtts://mqtt.example.com:8883",
+    "username": "user",
+    "password": "pass",
+    "topics": ["meshcore/SJC/#"]
+  }
+]
+```
+
+## Branding
+
+| Field | Description |
+|-------|-------------|
+| `branding.siteName` | Site title shown in the nav bar |
+| `branding.tagline` | Subtitle on the home page |
+| `branding.logoUrl` | URL to a custom logo image |
+| `branding.faviconUrl` | URL to a custom favicon |
+
+## Theme
+
+Colors used throughout the UI. All values are hex color codes.
+
+| Field | Description |
+|-------|-------------|
+| `theme.accent` | Primary accent color (links, buttons) |
+| `theme.navBg` | Navigation bar background |
+| `theme.navBg2` | Secondary nav background |
+| `theme.statusGreen` | Healthy status color |
+| `theme.statusYellow` | Degraded status color |
+| `theme.statusRed` | Silent/error status color |
+
+See [Customization](customization.md) for the full list — the theme customizer exposes every color.
+
+## Node colors
+
+Default marker colors by role:
+
+```json
+"nodeColors": {
+  "repeater": "#dc2626",
+  "companion": "#2563eb",
+  "room": "#16a34a",
+  "sensor": "#d97706",
+  "observer": "#8b5cf6"
+}
+```
+
+## Health thresholds
+
+How long (in hours) before a node is marked degraded or silent:
+
+| Field | Default | Description |
+|-------|---------|-------------|
+| `healthThresholds.infraDegradedHours` | `24` | Repeaters/rooms → degraded after this many hours |
+| `healthThresholds.infraSilentHours` | `72` | Repeaters/rooms → silent after this many hours |
+| `healthThresholds.nodeDegradedHours` | `1` | Companions/others → degraded |
+| `healthThresholds.nodeSilentHours` | `24` | Companions/others → silent |
+
+## Retention
+
+| Field | Default | Description |
+|-------|---------|-------------|
+| `retention.nodeDays` | `7` | Nodes not seen in N days move to inactive |
+| `retention.packetDays` | `30` | Packets older than N days are deleted daily |
+
+## Channel decryption
+
+| Field | Description |
+|-------|-------------|
+| `channelKeys` | Object of `"label": "hex-key"` pairs for decrypting channel messages |
+| `hashChannels` | Array of channel names (e.g., `"#LongFast"`) to match by hash |
+
+See [Channels](channels.md) for details.
+
+## Map defaults
+
+```json
+"mapDefaults": {
+  "center": [37.45, -122.0],
+  "zoom": 9
+}
+```
+
+Initial map center and zoom level.
+
+## Regions
+
+```json
+"regions": {
+  "SJC": "San Jose, US",
+  "SFO": "San Francisco, US"
+}
+```
+
+Named regions for the region filter dropdown. The `defaultRegion` field sets which region is selected by default.
+
+## Cache TTL
+
+All values in seconds. Controls how long the server caches API responses:
+
+```json
+"cacheTTL": {
+  "stats": 10,
+  "nodeList": 90,
+  "nodeDetail": 300,
+  "analyticsRF": 1800
+}
+```
+
+Lower values = fresher data but more server load.
+
+## Packet store
+
+| Field | Default | Description |
+|-------|---------|-------------|
+| `packetStore.maxMemoryMB` | `1024` | Maximum RAM for in-memory packet store |
+| `packetStore.estimatedPacketBytes` | `450` | Estimated bytes per packet (for memory budgeting) |
+
+## Timestamps
+
+| Field | Default | Description |
+|-------|---------|-------------|
+| `timestamps.defaultMode` | `"ago"` | Display mode: `"ago"` (relative) or `"absolute"` |
+| `timestamps.timezone` | `"local"` | `"local"` or `"utc"` |
+| `timestamps.formatPreset` | `"iso"` | Date format preset |
+
+## Live map
+
+| Field | Default | Description |
+|-------|---------|-------------|
+| `liveMap.propagationBufferMs` | `5000` | How long to buffer observations before animating |
+
+## HTTPS
+
+```json
+"https": {
+  "cert": "/path/to/cert.pem",
+  "key": "/path/to/key.pem"
+}
+```
+
+Provide cert and key paths to enable HTTPS.
+
+## Home page
+
+The `home` section customizes the onboarding experience. See `config.example.json` for the full structure including `steps`, `checklist`, and `footerLinks`.

docs/user-guide/customization.md

@@ -0,0 +1,78 @@
+# Customization
+
+CoreScope includes a built-in theme customizer. Access it from **Tools → Customization** in the navigation menu.
+
+[Screenshot: theme customizer panel with color pickers]
+
+## What you can customize
+
+### Branding
+
+- **Site name** — displayed in the nav bar and browser tab
+- **Tagline** — shown on the home page
+- **Logo URL** — replace the default logo
+- **Favicon URL** — custom browser tab icon
+
+### Theme colors (Light & Dark)
+
+Every color in the UI is customizable:
+
+- **Accent** — primary color for links, buttons, highlights
+- **Navigation** — nav bar background, text, and muted text colors
+- **Background** — page background and content area
+- **Surfaces** — cards, panels, input fields, detail panes
+- **Status** — green (healthy), yellow (degraded), red (silent)
+- **Text** — primary text, muted text, borders
+- **Tables** — row stripe, hover, and selected row colors
+
+Both light and dark themes are independently configurable.
+
+### Node colors
+
+Set the color for each role: repeater, companion, room, sensor, observer. These colors appear on the map, in node badges, and throughout the UI.
+
+### Packet type colors
+
+Customize the color for each packet type: Advert, Channel Msg, Direct Msg, ACK, Request, Response, Trace, Path.
+
+### Home page
+
+Customize the onboarding experience:
+
+- Hero title and subtitle
+- Getting-started steps (emoji, title, description for each)
+- FAQ items
+- Footer links
+
+### Timestamps
+
+- **Display mode** — relative ("5 min ago") or absolute
+- **Timezone** — local or UTC
+- **Format preset** — ISO or other presets
+
+## Live preview
+
+Changes apply instantly as you edit. You see the result in real time without saving.
+
+## Exporting a theme
+
+Click **Export JSON** to download your customizations as a JSON file. This produces a config-compatible block you can paste into your `config.json`.
+
+## Importing a theme
+
+Click **Import JSON** and paste a previously exported theme. The customizer loads all values and applies them immediately.
+
+## Resetting
+
+Click **Reset to Defaults** to restore all settings to the built-in defaults.
+
+## How it works
+
+The customizer writes CSS custom properties (variables) to override the defaults. Exported JSON maps directly to the `theme`, `nodeColors`, `branding`, and `home` sections of [config.json](configuration.md).
+
+## Tips
+
+- Start with the accent color — it cascades through buttons, links, and highlights
+- Dark mode has its own color set (`themeDark`), independent of light mode
+- Node colors affect the [Map](map.md), [Live](live.md) page, and node badges everywhere
+- Export your theme before upgrading CoreScope, then re-import it after

docs/user-guide/faq.md

@@ -0,0 +1,65 @@
+# FAQ
+
+## 1. How do I add my node to CoreScope?
+
+Go to the **Home** page, search for your node by name or public key, and click **+ Claim**. Your node appears on the dashboard with live status.
+
+## 2. Why does my node show as "Silent"?
+
+Your node hasn't been heard by any observer within the configured threshold. For companions, the default is 24 hours. For repeaters, it's 72 hours. Check that your node is advertising and within range of an observer. See [Configuration](configuration.md) for threshold settings.
+
+## 3. What's the difference between "Last seen" and "Last heard"?
+
+**Last seen** updates only when a node sends an advertisement. **Last heard** updates on *any* traffic from that node. CoreScope uses whichever is more recent for status calculations.
+
+## 4. Why can't I read channel messages?
+
+You need the channel encryption key in your `config.json`. See [Channels](channels.md) for how to configure `channelKeys`.
+
+## 5. What do the packet types mean?
+
+| Type | Meaning |
+|------|---------|
+| Advert | Node announcing itself to the mesh |
+| Channel Msg | Group message on a named channel |
+| Direct Msg | Private message between two nodes |
+| ACK | Acknowledgment of a received packet |
+| Request | Query sent to the mesh |
+| Response | Reply to a request |
+| Trace | Route tracing packet |
+| Path | Path discovery/announcement |
+
+## 6. How do I filter packets by a specific node?
+
+On the [Packets](packets.md) page, use the filter bar and type `from:NodeName` or click a node's name anywhere in the UI to jump to its packets.
+
+## 7. Why do some nodes appear faded on the map?
+
+Faded markers indicate **stale** nodes — they haven't been heard recently. The threshold depends on the node's role.
+
+## 8. Can I run CoreScope without MQTT?
+
+Yes. You can POST packets directly to the `/api/packets` endpoint using the API key. However, MQTT is the standard way to ingest data from mesh observers.
+
+## 9. How do I change the map's default location?
+
+Set `mapDefaults.center` and `mapDefaults.zoom` in your `config.json`. See [Configuration](configuration.md).
+
+## 10. How do I share a link to a specific packet or view?
+
+CoreScope uses URL hashes for deep linking. Copy the URL from your browser — it includes the current page, filters, and selected items. Examples:
+
+- `#/packets/abc123` — a specific packet
+- `#/analytics?tab=collisions` — the hash issues tab
+- `#/nodes/pubkey123` — a specific node's detail page
+
+### Where is the API documentation?
+
+CoreScope auto-generates an OpenAPI 3.0 specification from its route definitions:
+
+- **Interactive docs (Swagger UI):** `/api/docs` — browse and test all 40+ endpoints from your browser
+- **Machine-readable spec:** `/api/spec` — import into Postman, Insomnia, or any OpenAPI tool
+
+The spec is always in sync with the running server. No manual maintenance needed.
+
+On the public instance: [analyzer.00id.net/api/docs](https://analyzer.00id.net/api/docs)

docs/user-guide/getting-started.md

@@ -0,0 +1,70 @@
+# Getting Started
+
+## What is CoreScope?
+
+CoreScope is a web-based analyzer for **MeshCore LoRa mesh networks**. It shows you every node, packet, and signal path in your mesh — in real time.
+
+Use it to monitor node health, debug connectivity, view decrypted channel messages, and understand how your mesh is performing.
+
+## What you need
+
+- A running CoreScope server (Go binary + SQLite database)
+- An MQTT broker feeding mesh packets into the CoreScope ingestor
+- A modern web browser
+
+## Quick start
+
+### 1. Configure
+
+Copy `config.example.json` to `config.json` and edit it:
+
+```json
+{
+  "port": 3000,
+  "apiKey": "pick-a-secret-key",
+  "mqtt": {
+    "broker": "mqtt://your-broker:1883",
+    "topic": "meshcore/+/+/packets"
+  }
+}
+```
+
+See [Configuration](configuration.md) for all options.
+
+### 2. Run
+
+Start both the ingestor (reads MQTT → writes to SQLite) and the server (serves the UI + API):
+
+```bash
+./corescope-ingestor &
+./corescope-server
+```
+
+### 3. Open the UI
+
+Go to `http://localhost:3000`. You'll see the **Home** page.
+
+- **New to MeshCore?** Choose "I'm new" for setup guides and tips.
+- **Already set up?** Choose "I know what I'm doing" to jump straight in.
+
+Search for your node by name or public key, then click **+ Claim** to add it to your personal dashboard.
+
+## What's on each page
+
+| Page | What it does |
+|------|-------------|
+| [Home](getting-started.md) | Your personal mesh dashboard — claimed nodes, health, stats |
+| [Nodes](nodes.md) | Browse all nodes with status, role, and filters |
+| [Packets](packets.md) | Inspect every packet — grouped or raw, with hex breakdown |
+| [Map](map.md) | See node locations on a live map |
+| [Live](live.md) | Watch packets flow in real time with map animations |
+| [Analytics](analytics.md) | Deep-dive charts: RF, topology, routes, hash stats |
+| [Channels](channels.md) | Read decrypted channel messages |
+
+## Home page features
+
+- **Claim nodes** — search and add nodes to "My Mesh" for at-a-glance status cards
+- **Node cards** — show status (🟢 Active / 🟡 Degraded / 🔴 Silent), SNR, hops, packet count, and 24h sparkline
+- **Health detail** — click a card to see full health: observers, recent packets, mini map
+- **Packet journey** — click a recent packet to see sender → observer flow
+- **Network stats** — total transmissions, nodes, observers, and 24h activity

docs/user-guide/live.md

@@ -0,0 +1,76 @@
+# Live
+
+The Live page shows packets flowing through your mesh in real time, with animated map visualizations.
+
+[Screenshot: live page with map animations and packet feed]
+
+## Real-time feed
+
+Packets appear as they arrive via WebSocket. Each entry shows:
+
+- Packet type icon and color
+- Sender name
+- Observer that captured it
+- SNR and hop count
+- Timestamp
+
+The feed scrolls automatically. New packets appear at the top.
+
+## Map animations
+
+When a packet arrives, the Live map animates the signal path:
+
+- A pulse appears at the sender's location
+- Lines animate from sender to each observer that heard the packet
+- Observer markers flash briefly on reception
+
+### Realistic propagation
+
+Enable **Realistic Propagation** in the controls to buffer observations of the same packet and animate them simultaneously — showing how a single transmission ripples through the mesh.
+
+### Ghost hops
+
+When enabled, intermediate relay hops are shown as faded markers even if they don't have known locations. Disable to show only nodes with GPS coordinates.
+
+## VCR mode
+
+The Live page has a built-in VCR (video cassette recorder) for packet replay.
+
+| Button | Action |
+|--------|--------|
+| ⏸ Pause | Freeze the feed. New packets are buffered but not displayed. |
+| ▶ Play | Resume live feed or start replay. |
+| ⏪ Rewind | Step backward through packet history. |
+| ⏩ Fast-forward | Replay at 2×, 4×, or 8× speed. |
+
+While paused, a badge shows how many packets arrived that you haven't seen yet.
+
+## Timeline
+
+The timeline bar at the bottom shows packet activity over the selected time scope (default: 1 hour). Click anywhere on the timeline to jump to that point in time.
+
+## Packet type legend
+
+Each packet type has a color and icon:
+
+| Type | Icon | Color |
+|------|------|-------|
+| Advert | 📡 | Green |
+| Channel Msg | 💬 | Blue |
+| Direct Msg | ✉️ | Amber |
+| ACK | ✓ | Gray |
+| Request | ❓ | Purple |
+| Response | 📨 | Cyan |
+| Trace | 🔍 | Pink |
+| Path | 🛤️ | Teal |
+
+## Controls
+
+- **Favorites only** — show only packets from your claimed nodes
+- **Matrix mode** — visual effect overlay (just for fun)
+
+## Tips
+
+- Use VCR pause when you spot something interesting — then step through packet by packet
+- Realistic propagation mode is best for understanding multi-path reception
+- The timeline sparkline shows traffic patterns — useful for spotting quiet periods or bursts

docs/user-guide/map.md

@@ -0,0 +1,71 @@
+# Map
+
+The Map page shows all nodes on an interactive map, color-coded by role.
+
+[Screenshot: map with colored markers and controls panel]
+
+## Marker shapes and colors
+
+Each node role has a distinct shape and color:
+
+| Role | Shape | Default Color |
+|------|-------|---------------|
+| Repeater | Diamond | Red |
+| Companion | Circle | Blue |
+| Room | Square | Green |
+| Sensor | Triangle | Orange |
+| Observer | Star | Purple |
+
+Stale nodes (not heard recently) appear faded.
+
+## Hash labels
+
+Repeaters can display their short mesh hash ID instead of a plain marker. Toggle **Hash Labels** in the map controls to switch between icon markers and hash-labeled markers.
+
+## Map controls
+
+Open the controls panel with the ⚙️ button (top-right corner).
+
+### Node types
+
+Check or uncheck roles to show/hide them on the map. All roles are visible by default.
+
+### Byte size filter
+
+Filter nodes by packet size category: All, Small, Medium, Large.
+
+### Status filter
+
+Show only active, degraded, or silent nodes.
+
+### Last heard filter
+
+Limit the map to nodes heard within a time window (e.g., 24h, 7d, 30d).
+
+### Clustering
+
+Enable clustering to group nearby nodes into cluster bubbles. Zoom in to expand clusters.
+
+### Neighbor filter
+
+Select a reference node to highlight only its direct neighbors.
+
+## Show Route
+
+Click a node marker, then click **Show Route** in the popup to see the paths packets take to reach that node. Routes are drawn as lines between nodes.
+
+## Popups
+
+Click any marker to see:
+
+- Node name and role
+- Public key
+- Last seen timestamp
+- Link to the full node detail page
+
+## Tips
+
+- Zoom in on dense areas to see individual nodes
+- Use the role checkboxes to isolate repeaters and understand coverage
+- The neighbor filter is great for seeing which nodes can directly hear each other
+- Node colors are [customizable](customization.md) in the theme settings

docs/user-guide/nodes.md

@@ -0,0 +1,70 @@
+# Nodes
+
+The Nodes page lists every node your mesh has seen — repeaters, companions, rooms, and sensors.
+
+[Screenshot: nodes list with status indicators]
+
+## What you see
+
+Each row shows:
+
+- **Name** — the node's advertised name (or public key if unnamed)
+- **Role** — Repeater, Companion, Room, or Sensor
+- **Status** — color-coded health indicator
+- **Last seen** — when the node was last heard
+- **Advert count** — how many advertisements this node has sent
+
+## Status indicators
+
+| Indicator | Meaning |
+|-----------|---------|
+| 🟢 Active | Heard recently (within threshold for its role) |
+| 🟡 Degraded | Not heard for a while but not yet silent |
+| 🔴 Silent | Not heard for an extended period |
+
+Thresholds differ by role. Infrastructure nodes (repeaters, rooms) have longer grace periods than companions. See [Configuration](configuration.md) for `healthThresholds`.
+
+## Filtering
+
+### Role tabs
+
+Click **All**, **Repeaters**, **Rooms**, **Companions**, or **Sensors** to filter by role.
+
+### Search
+
+Type in the search box to filter by name or public key. The filter applies instantly.
+
+### Status filter
+
+Filter to show only active, degraded, or silent nodes.
+
+### Last heard filter
+
+Filter nodes by how recently they were heard (e.g., last hour, last 24h).
+
+## Sorting
+
+Click any column header to sort. Click again to reverse the order. Your sort preference is saved across sessions.
+
+## Node detail
+
+Click a node row to open the **detail pane** on the right. It shows:
+
+- Full public key
+- Role and status explanation
+- Location (if known)
+- Recent packets involving this node
+- Neighbor nodes
+- Signal statistics
+
+Click the node name in the detail pane to open the **full node page** with complete history, analytics, and health data.
+
+## Favorites
+
+Nodes you've claimed on the Home page appear as favorites. You can also star nodes directly from the Nodes page.
+
+## Tips
+
+- Use the search box for quick lookups — it matches partial names and keys
+- Sort by "Last seen" descending to find the most active nodes
+- The status explanation tells you exactly why a node is marked degraded or silent

docs/user-guide/packets.md

@@ -0,0 +1,78 @@
+# Packets
+
+The Packets page shows every transmission captured by your mesh observers.
+
+[Screenshot: packets table with grouped view]
+
+## Grouped vs ungrouped view
+
+By default, packets are **grouped by hash**. Each row represents one unique transmission, with a count of how many observers heard it.
+
+Click **Ungroup** to see every individual observation as its own row.
+
+Click the **▶** arrow on a grouped row to expand it and see all observations of that packet.
+
+## What each row shows
+
+- **Time** — when the packet was received
+- **From** — sender node name or hash prefix
+- **Type** — packet type (Advert, Channel Msg, Direct Msg, ACK, Request, Response, Trace, Path)
+- **Observer** — which observer captured the packet
+- **SNR** — signal-to-noise ratio in dB
+- **RSSI** — received signal strength
+- **Hops** — how many relay hops the packet took
+
+## Filters
+
+### Observer filter
+
+Select a specific observer to see only packets it captured. Saved across sessions.
+
+### Type filter
+
+Filter by packet type (e.g., show only Adverts or Channel Messages).
+
+### Time window
+
+Choose how far back to look: 15 minutes, 1 hour, 6 hours, 24 hours, etc. On mobile, the window is capped at 3 hours for performance.
+
+### Wireshark-style filter bar
+
+Type filter expressions for advanced filtering:
+
+```
+type:advert snr>5 hops<3
+from:MyNode observer:SJC
+```
+
+See the filter bar's help tooltip for all supported fields and operators.
+
+## Packet detail
+
+Click any row to open the **detail pane** on the right showing:
+
+- Full packet metadata (hash, type, size, timestamp)
+- Decoded payload fields
+- Hop path with resolved node names
+- All observers that heard this packet, sorted by SNR
+
+### Hex breakdown
+
+The detail pane includes a hex dump of the raw packet bytes with field boundaries highlighted.
+
+## Observation sorting
+
+When viewing a grouped packet's observations, they're sorted by SNR (best signal first). This helps you see which observer had the clearest reception.
+
+## Display options
+
+- **Hex hashes** — toggle to show packet hashes in hex format
+- **Panel resize** — drag the detail pane border to resize it
+- **Keyboard shortcuts** — press `Esc` to close the detail pane
+
+## Tips
+
+- Grouped view is best for understanding what's happening on the mesh
+- Ungrouped view is best for debugging signal paths and comparing observers
+- The time window filter is your best friend for managing large datasets
+- Packet hashes in the URL are deep-linkable — share a link to a specific packet

internal/sigvalidate/go.mod

@@ -0,0 +1,3 @@
+module github.com/meshcore-analyzer/sigvalidate
+
+go 1.22

internal/sigvalidate/sigvalidate.go

@@ -0,0 +1,23 @@
+// Package sigvalidate provides Ed25519 signature validation for MeshCore adverts.
+package sigvalidate
+
+import (
+	"crypto/ed25519"
+	"encoding/binary"
+)
+
+// ValidateAdvertSignature verifies an Ed25519 signature over a MeshCore advert.
+// The signed message is: pubKey (32 bytes) || timestamp (4 bytes LE) || appdata.
+// Returns false if pubKey is not 32 bytes or signature is not 64 bytes.
+func ValidateAdvertSignature(pubKey, signature []byte, timestamp uint32, appdata []byte) bool {
+	if len(pubKey) != 32 || len(signature) != 64 {
+		return false
+	}
+
+	message := make([]byte, 32+4+len(appdata))
+	copy(message[0:32], pubKey)
+	binary.LittleEndian.PutUint32(message[32:36], timestamp)
+	copy(message[36:], appdata)
+
+	return ed25519.Verify(ed25519.PublicKey(pubKey), message, signature)
+}

public/app.js

@@ -104,6 +104,46 @@ function timeAgo(iso) {
   return value + suffix + ' ago';
 }
 
+function getHashParams() {
+  return new URLSearchParams(location.hash.split('?')[1] || '');
+}
+
+function getDistanceUnit() {
+  var stored = localStorage.getItem('meshcore-distance-unit');
+  if (stored === 'km') return 'km';
+  if (stored === 'mi') return 'mi';
+  // 'auto' or no value — locale detection
+  var milesLocales = ['en-us', 'en-gb'];
+  var lang = (typeof navigator !== 'undefined' && navigator.language || '').toLowerCase();
+  for (var i = 0; i < milesLocales.length; i++) {
+    if (lang === milesLocales[i] || lang.startsWith(milesLocales[i] + '-')) return 'mi';
+  }
+  return 'km';
+}
+window.getDistanceUnit = getDistanceUnit;
+
+function formatDistance(km) {
+  if (km == null || isNaN(+km)) return '—';
+  var d = +km;
+  var unit = getDistanceUnit();
+  if (unit === 'mi') {
+    var mi = d / 1.60934;
+    if (mi < 0.1) return Math.round(mi * 5280) + ' ft';
+    return mi.toFixed(1) + ' mi';
+  }
+  if (d < 1) return Math.round(d * 1000) + ' m';
+  return d.toFixed(1) + ' km';
+}
+window.formatDistance = formatDistance;
+
+function formatDistanceRound(km) {
+  if (km == null || isNaN(+km)) return '—';
+  var unit = getDistanceUnit();
+  if (unit === 'mi') return Math.round(+km / 1.60934) + ' mi';
+  return Math.round(+km) + ' km';
+}
+window.formatDistanceRound = formatDistanceRound;
+
 function getTimestampMode() {
   const saved = localStorage.getItem('meshcore-timestamp-mode');
   if (saved === 'ago' || saved === 'absolute') return saved;
@@ -136,13 +176,6 @@ function getTimestampCustomFormat() {
 function pad2(v) { return String(v).padStart(2, '0'); }
 function pad3(v) { return String(v).padStart(3, '0'); }
 
-function mergeUserHomeConfig(siteConfig, userTheme) {
-  if (!siteConfig || !userTheme || !userTheme.home || typeof userTheme.home !== 'object') return siteConfig;
-  const serverHome = (siteConfig.home && typeof siteConfig.home === 'object') ? siteConfig.home : {};
-  siteConfig.home = Object.assign({}, serverHome, userTheme.home);
-  return siteConfig;
-}
-
 function formatIsoLike(d, timezone, includeMs) {
   const useUtc = timezone === 'utc';
   const year = useUtc ? d.getUTCFullYear() : d.getFullYear();
@@ -470,12 +503,21 @@ function navigate() {
   currentPage = basePage;
 
   const app = document.getElementById('app');
+  // Pages with fixed-height containers (maps, virtual-scroll, split-panels)
+  const fixedPages = { packets: 1, nodes: 1, map: 1, live: 1, channels: 1, 'audio-lab': 1 };
+  app.classList.toggle('app-fixed', basePage in fixedPages);
   if (pages[basePage]?.init) {
     const t0 = performance.now();
     pages[basePage].init(app, routeParam);
     const ms = performance.now() - t0;
     if (ms > 100) console.warn(`[SLOW PAGE] ${basePage} init took ${Math.round(ms)}ms`);
     app.classList.remove('page-enter'); void app.offsetWidth; app.classList.add('page-enter');
+    // #630-7: SPA focus management — move focus to first heading or main content
+    requestAnimationFrame(function() {
+      var heading = app.querySelector('h1, h2, h3, [role="heading"]');
+      if (heading) { heading.setAttribute('tabindex', '-1'); heading.focus({ preventScroll: true }); }
+      else { app.setAttribute('tabindex', '-1'); app.focus({ preventScroll: true }); }
+    });
   } else {
     app.innerHTML = `<div style="padding:40px;text-align:center;color:#6b7280"><h2>${route}</h2><p>Page not yet implemented.</p></div>`;
   }
@@ -794,92 +836,30 @@ window.addEventListener('DOMContentLoaded', () => {
   debouncedOnWS(function () { updateNavStats(); });
 
   // --- Theme Customization ---
-  // Fetch theme config and apply branding/colors before first render
+  // Fetch theme config and apply via customizer v2 pipeline
   fetch('/api/config/theme', { cache: 'no-store' }).then(r => r.json()).then(cfg => {
-    window.SITE_CONFIG = cfg || {};
-    if (!window.SITE_CONFIG.timestamps) window.SITE_CONFIG.timestamps = {};
-    const tsCfg = window.SITE_CONFIG.timestamps;
+    // Normalize timestamp defaults
+    cfg = cfg || {};
+    if (!cfg.timestamps) cfg.timestamps = {};
+    const tsCfg = cfg.timestamps;
     if (tsCfg.defaultMode !== 'absolute' && tsCfg.defaultMode !== 'ago') tsCfg.defaultMode = 'ago';
     if (tsCfg.timezone !== 'utc' && tsCfg.timezone !== 'local') tsCfg.timezone = 'local';
     if (tsCfg.formatPreset !== 'iso' && tsCfg.formatPreset !== 'iso-seconds' && tsCfg.formatPreset !== 'locale') tsCfg.formatPreset = 'iso';
     if (typeof tsCfg.customFormat !== 'string') tsCfg.customFormat = '';
     tsCfg.allowCustomFormat = tsCfg.allowCustomFormat === true;
 
-    // User's localStorage preferences take priority over server config
-    const userTheme = (() => { try { return JSON.parse(localStorage.getItem('meshcore-user-theme') || '{}'); } catch { return {}; } })();
-    window._SITE_CONFIG_ORIGINAL_HOME = JSON.parse(JSON.stringify(window.SITE_CONFIG.home || {}));
-    mergeUserHomeConfig(window.SITE_CONFIG, userTheme);
-
-    // Apply CSS variable overrides from theme config (skipped if user has local overrides)
-    if (!userTheme.theme && !userTheme.themeDark) {
-      const dark = document.documentElement.getAttribute('data-theme') === 'dark' ||
-        (document.documentElement.getAttribute('data-theme') !== 'light' && window.matchMedia('(prefers-color-scheme: dark)').matches);
-      const themeData = dark ? { ...(cfg.theme || {}), ...(cfg.themeDark || {}) } : (cfg.theme || {});
-      const root = document.documentElement.style;
-      const varMap = {
-        accent: '--accent', accentHover: '--accent-hover',
-        navBg: '--nav-bg', navBg2: '--nav-bg2', navText: '--nav-text', navTextMuted: '--nav-text-muted',
-        background: '--surface-0', text: '--text', textMuted: '--text-muted', border: '--border',
-        statusGreen: '--status-green', statusYellow: '--status-yellow', statusRed: '--status-red',
-        surface1: '--surface-1', surface2: '--surface-2', surface3: '--surface-3',
-        cardBg: '--card-bg', contentBg: '--content-bg', inputBg: '--input-bg',
-        rowStripe: '--row-stripe', rowHover: '--row-hover', detailBg: '--detail-bg',
-        selectedBg: '--selected-bg', sectionBg: '--section-bg',
-        font: '--font', mono: '--mono'
-      };
-      for (const [key, cssVar] of Object.entries(varMap)) {
-        if (themeData[key]) root.setProperty(cssVar, themeData[key]);
-      }
-      // Derived vars
-      if (themeData.background) root.setProperty('--content-bg', themeData.contentBg || themeData.background);
-      if (themeData.surface1) root.setProperty('--card-bg', themeData.cardBg || themeData.surface1);
-      // Nav gradient
-      if (themeData.navBg) {
-        const nav = document.querySelector('.top-nav');
-        if (nav) nav.style.background = `linear-gradient(135deg, ${themeData.navBg} 0%, ${themeData.navBg2 || themeData.navBg} 50%, ${themeData.navBg} 100%)`;
-      }
+    // Customizer v2: set server defaults and run full pipeline
+    // (reads localStorage overrides → merges → sets SITE_CONFIG → applies CSS → dispatches theme-changed)
+    if (window._customizerV2) {
+      window._customizerV2.init(cfg);
+    } else {
+      // Fallback if customize-v2.js didn't load
+      window.SITE_CONFIG = cfg;
     }
-
-    // Apply node color overrides (skip if user has local preferences)
-    if (cfg.nodeColors && !userTheme.nodeColors) {
-      for (const [role, color] of Object.entries(cfg.nodeColors)) {
-        if (window.ROLE_COLORS && role in window.ROLE_COLORS) window.ROLE_COLORS[role] = color;
-        if (window.ROLE_STYLE && window.ROLE_STYLE[role]) window.ROLE_STYLE[role].color = color;
-      }
-    }
-
-    // Apply type color overrides (skip if user has local preferences)
-    if (cfg.typeColors && !userTheme.typeColors) {
-      for (const [type, color] of Object.entries(cfg.typeColors)) {
-        if (window.TYPE_COLORS && type in window.TYPE_COLORS) window.TYPE_COLORS[type] = color;
-      }
-      if (window.syncBadgeColors) window.syncBadgeColors();
-    }
-
-    // Apply branding (skip if user has local preferences)
-    if (cfg.branding && !userTheme.branding) {
-      if (cfg.branding.siteName) {
-        document.title = cfg.branding.siteName;
-        const brandText = document.querySelector('.brand-text');
-        if (brandText) brandText.textContent = cfg.branding.siteName;
-      }
-      if (cfg.branding.logoUrl) {
-        const brandIcon = document.querySelector('.brand-icon');
-        if (brandIcon) {
-          const img = document.createElement('img');
-          img.src = cfg.branding.logoUrl;
-          img.alt = cfg.branding.siteName || 'Logo';
-          img.style.height = '24px';
-          img.style.width = 'auto';
-          brandIcon.replaceWith(img);
-        }
-      }
-      if (cfg.branding.faviconUrl) {
-        const favicon = document.querySelector('link[rel="icon"]');
-        if (favicon) favicon.href = cfg.branding.faviconUrl;
-      }
-    }
-  }).catch(() => { window.SITE_CONFIG = { timestamps: { defaultMode: 'ago', timezone: 'local', formatPreset: 'iso', customFormat: '', allowCustomFormat: false } }; }).finally(() => {
+  }).catch(() => {
+    window.SITE_CONFIG = { timestamps: { defaultMode: 'ago', timezone: 'local', formatPreset: 'iso', customFormat: '', allowCustomFormat: false } };
+    if (window._customizerV2) window._customizerV2.init(window.SITE_CONFIG);
+  }).finally(() => {
     if (!location.hash || location.hash === '#/') location.hash = '#/home';
     else navigate();
   });

public/channel-color-picker.js

@@ -0,0 +1,273 @@
+/**
+ * Channel Color Picker — Simplified popover with 8-color constrained palette (#674)
+ *
+ * Click a color dot next to channel names (channels page, live feed) to open picker.
+ * Right-click on live feed items retained as power-user shortcut (desktop only).
+ * No long-press. No custom color input. 8 preset colors.
+ *
+ * Uses ChannelColors.set/get/remove from channel-colors.js.
+ */
+(function() {
+  'use strict';
+
+  // 8 maximally-distinct colors on dark backgrounds (#674 Tufte spec)
+  var CHANNEL_PALETTE = [
+    '#ef4444', // red
+    '#f97316', // orange
+    '#eab308', // yellow
+    '#22c55e', // green
+    '#06b6d4', // cyan
+    '#3b82f6', // blue
+    '#8b5cf6', // violet
+    '#ec4899'  // pink
+  ];
+
+  var popoverEl = null;
+  var currentChannel = null;
+
+  function createPopover() {
+    if (popoverEl) return popoverEl;
+    var el = document.createElement('div');
+    el.className = 'cc-picker-popover';
+    el.setAttribute('role', 'dialog');
+    el.setAttribute('aria-label', 'Channel color picker');
+    el.style.display = 'none';
+    el.innerHTML =
+      '<div class="cc-picker-swatches" role="group" aria-label="Color swatches"></div>' +
+      '<button class="cc-picker-clear">Clear color</button>';
+
+    // Build swatches
+    var swatchContainer = el.querySelector('.cc-picker-swatches');
+    for (var i = 0; i < CHANNEL_PALETTE.length; i++) {
+      var sw = document.createElement('button');
+      sw.className = 'cc-swatch';
+      sw.style.background = CHANNEL_PALETTE[i];
+      sw.setAttribute('data-color', CHANNEL_PALETTE[i]);
+      sw.setAttribute('aria-label', CHANNEL_PALETTE[i]);
+      sw.title = CHANNEL_PALETTE[i];
+      sw.setAttribute('tabindex', '0');
+      swatchContainer.appendChild(sw);
+    }
+
+    // Event: swatch click
+    swatchContainer.addEventListener('click', function(e) {
+      var btn = e.target.closest('.cc-swatch');
+      if (!btn) return;
+      assignColor(btn.getAttribute('data-color'));
+    });
+
+    // Keyboard navigation for swatches
+    swatchContainer.addEventListener('keydown', function(e) {
+      var btn = e.target.closest('.cc-swatch');
+      if (!btn) return;
+      var swatches = swatchContainer.querySelectorAll('.cc-swatch');
+      var idx = Array.prototype.indexOf.call(swatches, btn);
+      if (idx < 0) return;
+      var next = -1;
+      if (e.key === 'ArrowRight' || e.key === 'ArrowDown') next = (idx + 1) % swatches.length;
+      else if (e.key === 'ArrowLeft' || e.key === 'ArrowUp') next = (idx - 1 + swatches.length) % swatches.length;
+      else if (e.key === 'Enter' || e.key === ' ') { assignColor(btn.getAttribute('data-color')); e.preventDefault(); return; }
+      if (next >= 0) { swatches[next].focus(); e.preventDefault(); }
+    });
+
+    // Event: clear
+    el.querySelector('.cc-picker-clear').addEventListener('click', function() {
+      if (currentChannel && window.ChannelColors) {
+        window.ChannelColors.remove(currentChannel);
+        refreshVisibleRows();
+      }
+      hidePopover();
+    });
+
+    // Prevent right-click on the popover itself
+    el.addEventListener('contextmenu', function(e) { e.preventDefault(); });
+
+    document.body.appendChild(el);
+    popoverEl = el;
+    return el;
+  }
+
+  function assignColor(color) {
+    if (currentChannel && window.ChannelColors) {
+      window.ChannelColors.set(currentChannel, color);
+      refreshVisibleRows();
+    }
+    hidePopover();
+  }
+
+  function showPopover(channel, x, y) {
+    var el = createPopover();
+    currentChannel = channel;
+
+    // Highlight current color
+    var current = window.ChannelColors ? window.ChannelColors.get(channel) : null;
+    var swatches = el.querySelectorAll('.cc-swatch');
+    for (var i = 0; i < swatches.length; i++) {
+      swatches[i].classList.toggle('cc-swatch-active', swatches[i].getAttribute('data-color') === current);
+    }
+
+    // Show/hide clear button
+    el.querySelector('.cc-picker-clear').style.display = current ? '' : 'none';
+
+    // Position
+    el.style.display = '';
+    var isTouch = window.matchMedia('(pointer: coarse)').matches;
+    if (!isTouch) {
+      el.style.left = '0';
+      el.style.top = '0';
+      var rect = el.getBoundingClientRect();
+      var pw = rect.width;
+      var ph = rect.height;
+      var vw = window.innerWidth;
+      var vh = window.innerHeight;
+      var finalX = x + pw > vw ? Math.max(0, vw - pw - 8) : x;
+      var finalY = y + ph > vh ? Math.max(0, vh - ph - 8) : y;
+      el.style.left = finalX + 'px';
+      el.style.top = finalY + 'px';
+    }
+
+    // Lock background scroll while popover is open
+    document.body.style.overflow = 'hidden';
+
+    // Focus first swatch for keyboard accessibility
+    var firstSwatch = el.querySelector('.cc-swatch');
+    if (firstSwatch) setTimeout(function() { firstSwatch.focus(); }, 0);
+
+    // Listen for outside click / Escape
+    setTimeout(function() {
+      document.addEventListener('click', onOutsideClick, true);
+      document.addEventListener('keydown', onEscape, true);
+    }, 0);
+  }
+
+  function hidePopover() {
+    if (popoverEl) popoverEl.style.display = 'none';
+    currentChannel = null;
+    document.body.style.overflow = '';
+    document.removeEventListener('click', onOutsideClick, true);
+    document.removeEventListener('keydown', onEscape, true);
+  }
+
+  function onOutsideClick(e) {
+    if (popoverEl && !popoverEl.contains(e.target)) {
+      hidePopover();
+    }
+  }
+
+  function onEscape(e) {
+    if (e.key === 'Escape') {
+      hidePopover();
+      e.stopPropagation();
+    }
+    // Trap Tab within the popover
+    if (e.key === 'Tab' && popoverEl && popoverEl.style.display !== 'none') {
+      var focusable = popoverEl.querySelectorAll('button, [tabindex]');
+      if (focusable.length === 0) return;
+      var first = focusable[0];
+      var last = focusable[focusable.length - 1];
+      if (e.shiftKey && document.activeElement === first) {
+        last.focus(); e.preventDefault();
+      } else if (!e.shiftKey && document.activeElement === last) {
+        first.focus(); e.preventDefault();
+      }
+    }
+  }
+
+  /** Refresh channel color styles on all visible feed items, channel list, and packet rows. */
+  function refreshVisibleRows() {
+    if (!window.ChannelColors) return;
+
+    // Live feed items
+    var feedItems = document.querySelectorAll('.live-feed-item');
+    for (var i = 0; i < feedItems.length; i++) {
+      var item = feedItems[i];
+      var ch = item._ccChannel;
+      if (!ch) continue;
+      var color = window.ChannelColors.get(ch);
+      item.style.borderLeft = color ? '3px solid ' + color : '';
+    }
+
+    // Update color dots everywhere
+    var dots = document.querySelectorAll('.ch-color-dot');
+    for (var j = 0; j < dots.length; j++) {
+      var dot = dots[j];
+      var dotCh = dot.getAttribute('data-channel');
+      if (!dotCh) continue;
+      var dotColor = window.ChannelColors.get(dotCh);
+      dot.style.background = dotColor || '';
+    }
+
+    // Channel list items — update border
+    var chItems = document.querySelectorAll('.ch-item[data-hash]');
+    for (var k = 0; k < chItems.length; k++) {
+      var chItem = chItems[k];
+      var hash = chItem.getAttribute('data-hash');
+      if (!hash) continue;
+      var chColor = window.ChannelColors.get(hash);
+      chItem.style.borderLeft = chColor ? '3px solid ' + chColor : '';
+    }
+
+    // Packets table — trigger re-render via custom event
+    document.dispatchEvent(new CustomEvent('channel-colors-changed'));
+  }
+
+  /**
+   * Install context-menu (right-click) handler on the live feed.
+   * No long-press — color dots handle mobile interaction.
+   */
+  function installLiveFeedHandlers() {
+    var feed = document.getElementById('liveFeed');
+    if (!feed) return;
+
+    // Click on color dot opens picker (#674)
+    feed.addEventListener('click', function(e) {
+      var dot = e.target.closest('.feed-color-dot');
+      if (!dot) return;
+      e.stopPropagation();
+      var ch = dot.getAttribute('data-channel');
+      if (ch) showPopover(ch, e.clientX, e.clientY);
+    });
+
+    feed.addEventListener('contextmenu', function(e) {
+      var item = e.target.closest('.live-feed-item');
+      if (!item || !item._ccChannel) return;
+      e.preventDefault();
+      showPopover(item._ccChannel, e.clientX, e.clientY);
+    });
+  }
+
+  /**
+   * Install context-menu handler on the packets table.
+   */
+  function installPacketsTableHandlers() {
+    var table = document.getElementById('packetsTableBody');
+    if (!table) return;
+
+    table.addEventListener('contextmenu', function(e) {
+      var row = e.target.closest('tr');
+      if (!row) return;
+      var chanTag = row.querySelector('.chan-tag');
+      if (chanTag) {
+        var ch = chanTag.textContent.trim();
+        if (ch) {
+          e.preventDefault();
+          showPopover(ch, e.clientX, e.clientY);
+          return;
+        }
+      }
+    });
+  }
+
+  // Export
+  window.ChannelColorPicker = {
+    install: function() {
+      installLiveFeedHandlers();
+      installPacketsTableHandlers();
+    },
+    installLiveFeed: installLiveFeedHandlers,
+    installPacketsTable: installPacketsTableHandlers,
+    show: showPopover,
+    hide: hidePopover,
+    PALETTE: CHANNEL_PALETTE
+  };
+})();

public/channel-colors.js

@@ -0,0 +1,109 @@
+/**
+ * Channel Color Highlighting — Storage Model (M1)
+ *
+ * localStorage key: 'live-channel-colors'
+ * Value: JSON object mapping channel names to hex colors
+ * e.g. { "#wardriving": "#ef4444", "#meshnet": "#3b82f6" }
+ *
+ * Only applies to GRP_TXT packets. Other types retain default styling.
+ */
+(function() {
+  'use strict';
+
+  var STORAGE_KEY = 'live-channel-colors';
+
+  function _load() {
+    try {
+      return JSON.parse(localStorage.getItem(STORAGE_KEY)) || {};
+    } catch (e) {
+      return {};
+    }
+  }
+
+  function _save(colors) {
+    localStorage.setItem(STORAGE_KEY, JSON.stringify(colors));
+  }
+
+  /** Validate hex color format: #RGB or #RRGGBB */
+  var HEX_RE = /^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/;
+  function _isValidHex(color) {
+    return typeof color === 'string' && HEX_RE.test(color);
+  }
+
+  /** Normalize 3-digit hex to 6-digit: #abc → #aabbcc */
+  function _normalize(color) {
+    if (color.length === 4) {
+      return '#' + color[1] + color[1] + color[2] + color[2] + color[3] + color[3];
+    }
+    return color;
+  }
+
+  /**
+   * Get the assigned color for a channel, or null if unassigned.
+   * @param {string} channel - Channel name (e.g. "#test")
+   * @returns {string|null} Hex color or null
+   */
+  function getChannelColor(channel) {
+    if (!channel) return null;
+    var colors = _load();
+    return colors[channel] || null;
+  }
+
+  /**
+   * Assign a color to a channel.
+   * @param {string} channel - Channel name
+   * @param {string} color - Hex color (e.g. "#ef4444")
+   */
+  function setChannelColor(channel, color) {
+    if (!channel || !color) return;
+    if (!_isValidHex(color)) return;
+    var colors = _load();
+    colors[channel] = _normalize(color);
+    _save(colors);
+  }
+
+  /**
+   * Remove the color assignment for a channel.
+   * @param {string} channel - Channel name
+   */
+  function removeChannelColor(channel) {
+    if (!channel) return;
+    var colors = _load();
+    delete colors[channel];
+    _save(colors);
+  }
+
+  /**
+   * Get all channel-color assignments.
+   * @returns {Object} Map of channel name → hex color
+   */
+  function getAllChannelColors() {
+    return _load();
+  }
+
+  /**
+   * Compute inline style string for a feed row / table row based on channel color.
+   * Returns empty string if no channel color is assigned.
+   * @param {string} typeName - Packet type name (e.g. "GRP_TXT", "CHAN")
+   * @param {string|null} channel - Channel name from decoded payload
+   * @returns {string} Inline style string or empty
+   */
+  function getChannelRowStyle(typeName, channel) {
+    // Only GRP_TXT / CHAN packets get channel coloring
+    if (typeName !== 'GRP_TXT' && typeName !== 'CHAN') return '';
+    if (!channel) return '';
+    var color = getChannelColor(channel);
+    if (!color) return '';
+    // 3px left border only — minimal Tufte-style encoding (#674)
+    return 'border-left:3px solid ' + color + ';';
+  }
+
+  // Export to window for use by live.js and packets.js
+  window.ChannelColors = {
+    get: getChannelColor,
+    set: setChannelColor,
+    remove: removeChannelColor,
+    getAll: getAllChannelColors,
+    getRowStyle: getChannelRowStyle
+  };
+})();

public/channels.js

@@ -171,8 +171,11 @@
   async function showNodeDetail(name) {
     _nodePanelTrigger = document.activeElement;
     if (_focusTrapCleanup) { _focusTrapCleanup(); _focusTrapCleanup = null; }
+    var _capturedHash = selectedHash;
     const node = await lookupNode(name);
     selectedNode = name;
+    var _chBase = _capturedHash ? '#/channels/' + encodeURIComponent(_capturedHash) : '#/channels';
+    history.replaceState(null, '', _chBase + '?node=' + encodeURIComponent(name));
 
     let panel = document.getElementById('chNodePanel');
     if (!panel) {
@@ -234,6 +237,8 @@
     const panel = document.getElementById('chNodePanel');
     if (panel) panel.classList.remove('open');
     selectedNode = null;
+    var _chRestoreUrl = selectedHash ? '#/channels/' + encodeURIComponent(selectedHash) : '#/channels';
+    history.replaceState(null, '', _chRestoreUrl);
     if (_nodePanelTrigger && typeof _nodePanelTrigger.focus === 'function') {
       _nodePanelTrigger.focus();
       _nodePanelTrigger = null;
@@ -314,6 +319,9 @@
   let regionChangeHandler = null;
 
   function init(app, routeParam) {
+    var _initUrlParams = getHashParams();
+    var _pendingNode = _initUrlParams.get('node');
+
     app.innerHTML = `<div class="ch-layout">
       <div class="ch-sidebar" aria-label="Channel list">
         <div class="ch-sidebar-header">
@@ -347,8 +355,9 @@
     });
 
     loadObserverRegions();
-    loadChannels().then(() => {
-      if (routeParam) selectChannel(routeParam);
+    loadChannels().then(async function () {
+      if (routeParam) await selectChannel(routeParam);
+      if (_pendingNode && _pendingNode.length < 200) await showNodeDetail(_pendingNode);
     });
 
     // #89: Sidebar resize handle
@@ -394,6 +403,14 @@
 
     // Event delegation for channel selection (touch-friendly)
     document.getElementById('chList').addEventListener('click', (e) => {
+      // Color dot click — open picker, don't select channel
+      const dot = e.target.closest('.ch-color-dot');
+      if (dot && window.ChannelColorPicker) {
+        e.stopPropagation();
+        var ch = dot.getAttribute('data-channel');
+        if (ch) ChannelColorPicker.show(ch, e.clientX, e.clientY);
+        return;
+      }
       const item = e.target.closest('.ch-item[data-hash]');
       if (item) selectChannel(item.dataset.hash);
     });
@@ -670,12 +687,18 @@
         : `${ch.messageCount} messages`;
       const sel = selectedHash === ch.hash ? ' selected' : '';
       const abbr = name.startsWith('#') ? name.slice(0, 3) : name.slice(0, 2).toUpperCase();
+      // Channel color dot for color picker (#674)
+      const chColor = window.ChannelColors ? window.ChannelColors.get(ch.hash) : null;
+      const dotStyle = chColor ? ` style="background:${chColor}"` : '';
+      // Left border for assigned color
+      const borderStyle = chColor ? ` style="border-left:3px solid ${chColor}"` : '';
 
-      return `<button class="ch-item${sel}" data-hash="${ch.hash}" type="button" role="option" aria-selected="${selectedHash === ch.hash ? 'true' : 'false'}" aria-label="${escapeHtml(name)}">
+      return `<button class="ch-item${sel}" data-hash="${ch.hash}"${borderStyle} type="button" role="option" aria-selected="${selectedHash === ch.hash ? 'true' : 'false'}" aria-label="${escapeHtml(name)}">
         <div class="ch-badge" style="background:${color}" aria-hidden="true">${escapeHtml(abbr)}</div>
         <div class="ch-item-body">
           <div class="ch-item-top">
             <span class="ch-item-name">${escapeHtml(name)}</span>
+            <span class="ch-color-dot" data-channel="${escapeHtml(ch.hash)}"${dotStyle} title="Change channel color" aria-label="Change color for ${escapeHtml(name)}"></span>
             <span class="ch-item-time" data-channel-hash="${ch.hash}">${time}</span>
           </div>
           <div class="ch-item-preview">${escapeHtml(preview)}</div>

public/compare.js

@@ -48,7 +48,7 @@ if (typeof window !== 'undefined') window.comparePacketSets = comparePacketSets;
     packetsB = [];
     currentView = 'summary';
 
-    app.innerHTML = '<div class="compare-page" style="overflow-y:auto;height:calc(100vh - 56px);padding:16px">' +
+    app.innerHTML = '<div class="compare-page" style="padding:16px">' +
       '<div class="page-header" style="display:flex;align-items:center;gap:12px;margin-bottom:16px">' +
         '<a href="#/observers" class="btn-icon" title="Back to Observers" aria-label="Back">\u2190</a>' +
         '<h2 style="margin:0">\uD83D\uDD0D Observer Comparison</h2>' +

public/home.css

@@ -1,7 +1,6 @@
 /* === CoreScope — home.css === */
 
-/* Override #app overflow:hidden for home page scrolling */
-#app:has(.home-hero), #app:has(.home-chooser) { overflow-y: auto; }
+/* Home page now uses body scroll (no #app override needed — see style.css) */
 
 /* Chooser */
 .home-chooser {

public/home.js

@@ -511,27 +511,35 @@
   function timeSinceMs(d) { return Date.now() - d.getTime(); }
 
   function checklist(homeCfg) {
-    if (homeCfg?.checklist) {
-      return homeCfg.checklist.map(i => `<div class="checklist-item"><div class="checklist-q" role="button" tabindex="0" aria-expanded="false">${escapeHtml(i.question)}</div><div class="checklist-a">${window.miniMarkdown ? miniMarkdown(i.answer) : escapeHtml(i.answer)}</div></div>`).join('');
+    var html = '';
+    // Render steps (getting started guide)
+    if (homeCfg?.steps?.length) {
+      html += homeCfg.steps.map(s => `<div class="checklist-item"><div class="checklist-q" role="button" tabindex="0" aria-expanded="false">${escapeHtml(s.emoji || '')} ${escapeHtml(s.title)}</div><div class="checklist-a">${window.miniMarkdown ? miniMarkdown(s.description) : escapeHtml(s.description)}</div></div>`).join('');
     }
-    if (homeCfg?.steps) {
-      return homeCfg.steps.map(s => `<div class="checklist-item"><div class="checklist-q" role="button" tabindex="0" aria-expanded="false">${escapeHtml(s.emoji || '')} ${escapeHtml(s.title)}</div><div class="checklist-a">${window.miniMarkdown ? miniMarkdown(s.description) : escapeHtml(s.description)}</div></div>`).join('');
+    // Render FAQ/checklist (additional Q&A)
+    if (homeCfg?.checklist?.length) {
+      if (html) html += '<h3 style="margin:24px 0 12px;font-size:16px">❓ FAQ</h3>';
+      html += homeCfg.checklist.map(i => `<div class="checklist-item"><div class="checklist-q" role="button" tabindex="0" aria-expanded="false">${escapeHtml(i.question)}</div><div class="checklist-a">${window.miniMarkdown ? miniMarkdown(i.answer) : escapeHtml(i.answer)}</div></div>`).join('');
     }
-    const items = [
-      { q: '💬 First: Join the Bay Area MeshCore Discord',
-        a: '<p>The community Discord is the best place to get help and find local mesh enthusiasts.</p><p><a href="https://discord.gg/q59JzsYTst" target="_blank" rel="noopener" style="color:var(--accent);font-weight:600">Join the Discord ↗</a></p><p>Start with <strong>#intro-to-meshcore</strong> — it has detailed setup instructions.</p>' },
-      { q: '🔵 Step 1: Connect via Bluetooth',
-        a: '<p>Flash <strong>BLE companion</strong> firmware from <a href="https://flasher.meshcore.co.uk/" target="_blank" rel="noopener" style="color:var(--accent)">MeshCore Flasher</a>.</p><ul><li>Screenless devices: default PIN <code>123456</code></li><li>Screen devices: random PIN shown on display</li><li>If pairing fails: forget device, reboot, re-pair</li></ul>' },
-      { q: '📻 Step 2: Set the right frequency preset',
-        a: '<p><strong>US Recommended:</strong></p><div style="margin:8px 0;padding:8px 12px;background:var(--surface-1);border-radius:6px;font-family:var(--mono);font-size:.85rem">910.525 MHz · BW 62.5 kHz · SF 7 · CR 5</div><p>Select <strong>"US Recommended"</strong> in the app or flasher.</p>' },
-      { q: '📡 Step 3: Advertise yourself',
-        a: '<p>Tap the signal icon → <strong>Flood</strong> to broadcast your node to the mesh. Companions only advert when you trigger it manually.</p>' },
-      { q: '🔁 Step 4: Check "Heard N repeats"',
-        a: '<ul><li><strong>"Sent"</strong> = transmitted, no confirmation</li><li><strong>"Heard 0 repeats"</strong> = no repeater picked it up</li><li><strong>"Heard 1+ repeats"</strong> = you\'re on the mesh!</li></ul>' },
-      { q: '📍 Repeaters near you?',
-        a: '<p><a href="#/map" style="color:var(--accent)">Check the network map</a> to see active repeaters.</p>' }
-    ];
-    return items.map(i => `<div class="checklist-item"><div class="checklist-q" role="button" tabindex="0" aria-expanded="false">${i.q}</div><div class="checklist-a">${i.a}</div></div>`).join('');
+    // Fallback: Bay Area defaults when no config at all
+    if (!html) {
+      const items = [
+        { q: '💬 First: Join the Bay Area MeshCore Discord',
+          a: '<p>The community Discord is the best place to get help and find local mesh enthusiasts.</p><p><a href="https://discord.gg/q59JzsYTst" target="_blank" rel="noopener" style="color:var(--accent);font-weight:600">Join the Discord ↗</a></p><p>Start with <strong>#intro-to-meshcore</strong> — it has detailed setup instructions.</p>' },
+        { q: '🔵 Step 1: Connect via Bluetooth',
+          a: '<p>Flash <strong>BLE companion</strong> firmware from <a href="https://flasher.meshcore.co.uk/" target="_blank" rel="noopener" style="color:var(--accent)">MeshCore Flasher</a>.</p><ul><li>Screenless devices: default PIN <code>123456</code></li><li>Screen devices: random PIN shown on display</li><li>If pairing fails: forget device, reboot, re-pair</li></ul>' },
+        { q: '📻 Step 2: Set the right frequency preset',
+          a: '<p><strong>US Recommended:</strong></p><div style="margin:8px 0;padding:8px 12px;background:var(--surface-1);border-radius:6px;font-family:var(--mono);font-size:.85rem">910.525 MHz · BW 62.5 kHz · SF 7 · CR 5</div><p>Select <strong>"US Recommended"</strong> in the app or flasher.</p>' },
+        { q: '📡 Step 3: Advertise yourself',
+          a: '<p>Tap the signal icon → <strong>Flood</strong> to broadcast your node to the mesh. Companions only advert when you trigger it manually.</p>' },
+        { q: '🔁 Step 4: Check "Heard N repeats"',
+          a: '<ul><li><strong>"Sent"</strong> = transmitted, no confirmation</li><li><strong>"Heard 0 repeats"</strong> = no repeater picked it up</li><li><strong>"Heard 1+ repeats"</strong> = you\'re on the mesh!</li></ul>' },
+        { q: '📍 Repeaters near you?',
+          a: '<p><a href="#/map" style="color:var(--accent)">Check the network map</a> to see active repeaters.</p>' }
+      ];
+      html = items.map(i => `<div class="checklist-item"><div class="checklist-q" role="button" tabindex="0" aria-expanded="false">${i.q}</div><div class="checklist-a">${i.a}</div></div>`).join('');
+    }
+    return html;
   }
 
   registerPage('home', { init, destroy });

public/hop-resolver.js

@@ -8,9 +8,11 @@ window.HopResolver = (function() {
   const MAX_HOP_DIST = 1.8; // ~200km in degrees
   const REGION_RADIUS_KM = 300;
   let prefixIdx = {};   // lowercase hex prefix → [node, ...]
+  let pubkeyIdx = {};   // full lowercase pubkey → node (O(1) lookup)
   let nodesList = [];
   let observerIataMap = {}; // observer_id → iata
   let iataCoords = {};  // iata → {lat, lon}
+  let affinityMap = {}; // pubkey → { neighborPubkey → score }
 
   function dist(lat1, lon1, lat2, lon2) {
     return Math.sqrt((lat1 - lat2) ** 2 + (lon1 - lon2) ** 2);
@@ -34,9 +36,11 @@ window.HopResolver = (function() {
   function init(nodes, opts) {
     nodesList = nodes || [];
     prefixIdx = {};
+    pubkeyIdx = {};
     for (const n of nodesList) {
       if (!n.public_key) continue;
       const pk = n.public_key.toLowerCase();
+      pubkeyIdx[pk] = n;
       for (let len = 1; len <= 3; len++) {
         const p = pk.slice(0, len * 2);
         if (!prefixIdx[p]) prefixIdx[p] = [];
@@ -67,6 +71,34 @@ window.HopResolver = (function() {
     return null; // no GPS — can't geo-filter client-side
   }
 
+  /**
+   * Pick the best candidate using affinity first, then geo-distance fallback.
+   * @param {Array} candidates - candidates with lat/lon/pubkey/name
+   * @param {string|null} adjacentPubkey - pubkey of the previously/next resolved hop
+   * @param {Object|null} anchor - {lat, lon} for geo fallback
+   * @param {number|null} fallbackLat - fallback anchor lat (e.g. observer)
+   * @param {number|null} fallbackLon - fallback anchor lon
+   * @returns {Object} best candidate
+   */
+  function pickByAffinity(candidates, adjacentPubkey, anchor, fallbackLat, fallbackLon) {
+    // If we have affinity data and an adjacent hop, prefer neighbors
+    if (adjacentPubkey && Object.keys(affinityMap).length > 0) {
+      const withAffinity = candidates
+        .map(c => ({ ...c, affinity: getAffinity(adjacentPubkey, c.pubkey) }))
+        .filter(c => c.affinity > 0);
+      if (withAffinity.length > 0) {
+        withAffinity.sort((a, b) => b.affinity - a.affinity);
+        return withAffinity[0];
+      }
+    }
+    // Fallback: geo-distance sort (existing behavior)
+    const effectiveAnchor = anchor || (fallbackLat != null ? { lat: fallbackLat, lon: fallbackLon } : null);
+    if (effectiveAnchor) {
+      candidates.sort((a, b) => dist(a.lat, a.lon, effectiveAnchor.lat, effectiveAnchor.lon) - dist(b.lat, b.lon, effectiveAnchor.lat, effectiveAnchor.lon));
+    }
+    return candidates[0];
+  }
+
   /**
    * Resolve an array of hex hop prefixes to node info.
    * Returns a map: { hop: {name, pubkey, lat, lon, ambiguous, unreliable} }
@@ -139,40 +171,50 @@ window.HopResolver = (function() {
 
     // Forward pass
     let lastPos = (originLat != null && originLon != null) ? { lat: originLat, lon: originLon } : null;
+    let lastResolvedPubkey = null;
     for (let i = 0; i < hops.length; i++) {
       const hop = hops[i];
-      if (hopPositions[hop]) { lastPos = hopPositions[hop]; continue; }
+      if (hopPositions[hop]) {
+        lastPos = hopPositions[hop];
+        lastResolvedPubkey = resolved[hop] ? resolved[hop].pubkey : null;
+        continue;
+      }
       const r = resolved[hop];
       if (!r || !r.ambiguous) continue;
       const withLoc = r.candidates.filter(c => c.lat && c.lon && !(c.lat === 0 && c.lon === 0));
       if (!withLoc.length) continue;
-      let anchor = lastPos;
-      if (!anchor && i === hops.length - 1 && observerLat != null) {
-        anchor = { lat: observerLat, lon: observerLon };
-      }
-      if (anchor) {
-        withLoc.sort((a, b) => dist(a.lat, a.lon, anchor.lat, anchor.lon) - dist(b.lat, b.lon, anchor.lat, anchor.lon));
-      }
-      r.name = withLoc[0].name;
-      r.pubkey = withLoc[0].pubkey;
-      hopPositions[hop] = { lat: withLoc[0].lat, lon: withLoc[0].lon };
+
+      // Affinity-aware: prefer candidates that are neighbors of the previous hop
+      const picked = pickByAffinity(withLoc, lastResolvedPubkey, lastPos, i === hops.length - 1 ? observerLat : null, i === hops.length - 1 ? observerLon : null);
+      r.name = picked.name;
+      r.pubkey = picked.pubkey;
+      hopPositions[hop] = { lat: picked.lat, lon: picked.lon };
       lastPos = hopPositions[hop];
+      lastResolvedPubkey = picked.pubkey;
     }
 
     // Backward pass
     let nextPos = (observerLat != null && observerLon != null) ? { lat: observerLat, lon: observerLon } : null;
+    let nextResolvedPubkey = null;
     for (let i = hops.length - 1; i >= 0; i--) {
       const hop = hops[i];
-      if (hopPositions[hop]) { nextPos = hopPositions[hop]; continue; }
+      if (hopPositions[hop]) {
+        nextPos = hopPositions[hop];
+        nextResolvedPubkey = resolved[hop] ? resolved[hop].pubkey : null;
+        continue;
+      }
       const r = resolved[hop];
       if (!r || !r.ambiguous) continue;
       const withLoc = r.candidates.filter(c => c.lat && c.lon && !(c.lat === 0 && c.lon === 0));
       if (!withLoc.length || !nextPos) continue;
-      withLoc.sort((a, b) => dist(a.lat, a.lon, nextPos.lat, nextPos.lon) - dist(b.lat, b.lon, nextPos.lat, nextPos.lon));
-      r.name = withLoc[0].name;
-      r.pubkey = withLoc[0].pubkey;
-      hopPositions[hop] = { lat: withLoc[0].lat, lon: withLoc[0].lon };
+
+      // Affinity-aware: prefer candidates that are neighbors of the next hop
+      const picked = pickByAffinity(withLoc, nextResolvedPubkey, nextPos, null, null);
+      r.name = picked.name;
+      r.pubkey = picked.pubkey;
+      hopPositions[hop] = { lat: picked.lat, lon: picked.lon };
       nextPos = hopPositions[hop];
+      nextResolvedPubkey = picked.pubkey;
     }
 
     // Sanity check: drop hops impossibly far from neighbors
@@ -203,5 +245,53 @@ window.HopResolver = (function() {
     return nodesList.length > 0;
   }
 
-  return { init: init, resolve: resolve, ready: ready, haversineKm: haversineKm };
+  /**
+   * Load neighbor-graph affinity data.
+   * @param {Object} graph - { edges: [{source, target, score, weight}, ...] }
+   */
+  function setAffinity(graph) {
+    affinityMap = {};
+    if (!graph || !graph.edges) return;
+    for (const e of graph.edges) {
+      if (!affinityMap[e.source]) affinityMap[e.source] = {};
+      affinityMap[e.source][e.target] = e.score || e.weight || 1;
+      if (!affinityMap[e.target]) affinityMap[e.target] = {};
+      affinityMap[e.target][e.source] = e.score || e.weight || 1;
+    }
+  }
+
+  /**
+   * Get the affinity score between two pubkeys (0 if not neighbors).
+   */
+  function getAffinity(pubkeyA, pubkeyB) {
+    if (!pubkeyA || !pubkeyB || !affinityMap[pubkeyA]) return 0;
+    return affinityMap[pubkeyA][pubkeyB] || 0;
+  }
+
+  /**
+   * Resolve hops using server-provided resolved_path (full pubkeys).
+   * Returns the same format as resolve() — { [hop]: { name, pubkey, ... } }.
+   * resolved_path is an array aligned with path_json: each element is a
+   * 64-char lowercase hex pubkey or null. Skips entries that are null.
+   */
+  function resolveFromServer(hops, resolvedPath) {
+    if (!hops || !resolvedPath || hops.length !== resolvedPath.length) return {};
+    var result = {};
+    for (var i = 0; i < hops.length; i++) {
+      var hop = hops[i];
+      var pubkey = resolvedPath[i];
+      if (!pubkey) continue; // null = unresolved, leave for client-side fallback
+      // O(1) lookup via pubkeyIdx built during init()
+      var node = pubkeyIdx[pubkey.toLowerCase()] || null;
+      result[hop] = {
+        name: node ? node.name : pubkey.slice(0, 8),
+        pubkey: pubkey,
+        candidates: node ? [{ name: node.name, pubkey: pubkey, lat: node.lat, lon: node.lon }] : [],
+        conflicts: []
+      };
+    }
+    return result;
+  }
+
+  return { init: init, resolve: resolve, resolveFromServer: resolveFromServer, ready: ready, haversineKm: haversineKm, setAffinity: setAffinity, getAffinity: getAffinity };
 })();

public/index.html

@@ -86,17 +86,22 @@
 
   <script src="vendor/qrcode.js"></script>
   <script src="roles.js?v=__BUST__"></script>
-  <script src="customize.js?v=__BUST__" onerror="console.error('Failed to load:', this.src)"></script>
+  <script src="customize-v2.js?v=__BUST__" onerror="console.error('Failed to load:', this.src)"></script>
   <script src="region-filter.js?v=__BUST__"></script>
   <script src="hop-resolver.js?v=__BUST__"></script>
   <script src="hop-display.js?v=__BUST__"></script>
   <script src="app.js?v=__BUST__"></script>
   <script src="home.js?v=__BUST__"></script>
+  <script src="table-sort.js?v=__BUST__"></script>
   <script src="packet-filter.js?v=__BUST__"></script>
+  <script src="packet-helpers.js?v=__BUST__"></script>
+  <script src="channel-colors.js?v=__BUST__"></script>
+  <script src="channel-color-picker.js?v=__BUST__"></script>
   <script src="packets.js?v=__BUST__"></script>
   <script src="geo-filter-overlay.js?v=__BUST__"></script>
   <script src="map.js?v=__BUST__" onerror="console.error('Failed to load:', this.src)"></script>
   <script src="channels.js?v=__BUST__" onerror="console.error('Failed to load:', this.src)"></script>
+  <script src="table-sort.js?v=__BUST__"></script>
   <script src="nodes.js?v=__BUST__" onerror="console.error('Failed to load:', this.src)"></script>
   <script src="traces.js?v=__BUST__" onerror="console.error('Failed to load:', this.src)"></script>
   <script src="analytics.js?v=__BUST__" onerror="console.error('Failed to load:', this.src)"></script>

public/live.css

@@ -19,6 +19,36 @@
   position: absolute;
   z-index: 1000;
   pointer-events: auto;
+  display: flex;
+  flex-direction: column;
+}
+
+/* ---- Panel header (non-scrolling) ---- */
+.panel-header {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  flex-shrink: 0;
+  padding: 4px 6px;
+}
+
+/* ---- Panel content (scrollable) ---- */
+.panel-content {
+  flex: 1;
+  overflow-y: auto;
+  min-height: 0;
+}
+
+.live-feed .panel-content {
+  display: flex;
+  flex-direction: column;
+  gap: 1px;
+}
+
+.live-legend .panel-content {
+  display: flex;
+  flex-direction: column;
+  gap: 3px;
 }
 
 /* ---- Header / Stats ---- */
@@ -106,7 +136,6 @@
   right: 12px;
   width: 320px;
   max-height: calc(100vh - 140px);
-  overflow-y: auto;
   background: color-mix(in srgb, var(--surface-1) 95%, transparent);
   backdrop-filter: blur(12px);
   border-radius: 10px;
@@ -126,16 +155,12 @@
   left: 12px;
   width: 360px;
   max-height: 340px;
-  overflow-y: auto;
   background: color-mix(in srgb, var(--surface-1) 92%, transparent);
   backdrop-filter: blur(12px);
   border-radius: 10px;
   border: 1px solid var(--border);
   box-shadow: 0 4px 24px rgba(0, 0, 0, 0.5);
   padding: 6px;
-  display: flex;
-  flex-direction: column;
-  gap: 1px;
 }
 
 .live-feed-item {
@@ -198,9 +223,15 @@
   box-shadow: 0 4px 24px rgba(0, 0, 0, 0.5);
   color: var(--text-muted);
   font-size: 11px;
-  display: flex;
-  flex-direction: column;
-  gap: 3px;
+  transition: opacity 0.3s, transform 0.3s;
+}
+
+/* Collapsible legend (#279) */
+.live-legend.hidden {
+  opacity: 0;
+  transform: translateX(100%);
+  pointer-events: none;
+  visibility: hidden;
 }
 
 .legend-title {
@@ -272,6 +303,16 @@
   background: rgba(59, 130, 246, 0.2) !important;
 }
 
+/* ---- Medium breakpoint (#279) ---- */
+@media (max-width: 768px) {
+  .live-feed { width: 280px; max-height: 200px; }
+  .live-node-detail { width: 260px; }
+  .live-legend { font-size: 10px; padding: 8px 10px; }
+  .live-header { gap: 8px; padding: 6px 12px; }
+  .live-stat-pill { font-size: 11px; padding: 2px 8px; }
+  .live-toggles { font-size: 10px; gap: 6px; }
+}
+
 /* ---- Responsive ---- */
 @media (max-width: 640px) {
   .live-feed { display: none !important; }
@@ -702,9 +743,8 @@
   border: 0;
 }
 
-/* Legend toggle button for mobile (#60) */
+/* Legend toggle button — visible at all sizes (#60, #279) */
 .legend-toggle-btn {
-  display: none;
   position: absolute;
   bottom: 82px;
   right: 12px;
@@ -760,3 +800,52 @@
 }
 .nav-pin-btn:hover { opacity: 0.8; }
 .nav-pin-btn.pinned { opacity: 1; filter: drop-shadow(0 0 4px rgba(59,130,246,0.5)); }
+
+/* ========== Panel Corner Positioning (#608 M0) ========== */
+/* Corner positions — applied via data-position attribute on .live-overlay panels */
+.live-overlay[data-position="tl"] { top: 64px; left: 12px; bottom: auto; right: auto; }
+.live-overlay[data-position="tr"] { top: 64px; right: 12px; bottom: auto; left: auto; }
+.live-overlay[data-position="bl"] { bottom: 12px; left: 12px; top: auto; right: auto; }
+.live-overlay[data-position="br"] { bottom: 12px; right: 12px; top: auto; left: auto; }
+
+/* Override hide animations for positioned panels — slide toward nearest edge */
+.live-overlay[data-position="tl"].hidden,
+.live-overlay[data-position="bl"].hidden { transform: translateX(-100%); }
+.live-overlay[data-position="tr"].hidden,
+.live-overlay[data-position="br"].hidden { transform: translateX(100%); }
+.live-overlay[data-position].hidden { opacity: 0; pointer-events: none; visibility: hidden; }
+
+/* Corner toggle button */
+.panel-corner-btn {
+  width: 28px;
+  height: 28px;
+  padding: 0;
+  border: none;
+  background: transparent;
+  color: var(--text-muted);
+  cursor: pointer;
+  opacity: 0.6;
+  transition: opacity 0.15s, background 0.15s;
+  font-size: 14px;
+  line-height: 28px;
+  text-align: center;
+  flex-shrink: 0;
+  border-radius: 4px;
+}
+.panel-corner-btn:hover { opacity: 1; background: color-mix(in srgb, var(--text) 12%, transparent); }
+.panel-corner-btn:focus-visible {
+  opacity: 1;
+  outline: 2px solid var(--accent);
+  outline-offset: 2px;
+  border-radius: 3px;
+}
+
+/* On mobile, corner toggle is not useful (panels are hidden or bottom-sheet) */
+@media (max-width: 640px) {
+  .panel-corner-btn { display: none !important; }
+  .live-overlay[data-position] {
+    top: unset !important; bottom: unset !important;
+    left: unset !important; right: unset !important;
+  }
+}
+

public/live.js

@@ -1,6 +1,10 @@
 (function() {
   'use strict';
 
+  // getParsedPath / getParsedDecoded are in shared packet-helpers.js (loaded before this file)
+  var getParsedPath = window.getParsedPath;
+  var getParsedDecoded = window.getParsedDecoded;
+
   // Status color helpers (read from CSS variables for theme support)
   function cssVar(name) { return getComputedStyle(document.documentElement).getPropertyValue(name).trim(); }
   function statusGreen() { return cssVar('--status-green') || '#22c55e'; }
@@ -39,6 +43,7 @@
     timelineScope: 3600000, // 1h default ms
     timelineTimestamps: [], // historical timestamps from DB for sparkline
     timelineFetchedScope: 0, // last fetched scope to avoid redundant fetches
+    replayGen: 0,            // generation counter — incremented on each replay/rewind to discard stale async results
   };
 
   // ROLE_COLORS loaded from shared roles.js (includes 'unknown')
@@ -53,6 +58,92 @@
     REQUEST: '❓', RESPONSE: '📨', TRACE: '🔍', PATH: '🛤️'
   };
 
+  /* ---- Panel Corner Positioning (#608 M0) ---- */
+  var PANEL_DEFAULTS = { liveFeed: 'bl', liveLegend: 'br', liveNodeDetail: 'tr' };
+  var CORNER_CYCLE = ['tl', 'tr', 'br', 'bl'];
+  var CORNER_ARROWS = { tl: '↘', tr: '↙', bl: '↗', br: '↖' };
+  var CORNER_LABELS = { tl: 'top-left', tr: 'top-right', bl: 'bottom-left', br: 'bottom-right' };
+  var PANEL_NAMES = { liveFeed: 'Feed', liveLegend: 'Legend', liveNodeDetail: 'Node detail' };
+
+  function getPanelPositions() {
+    var pos = {};
+    for (var id in PANEL_DEFAULTS) {
+      try { pos[id] = localStorage.getItem('panel-corner-' + id) || PANEL_DEFAULTS[id]; }
+      catch (_) { pos[id] = PANEL_DEFAULTS[id]; }
+    }
+    return pos;
+  }
+
+  function nextAvailableCorner(panelId, desired, allPositions) {
+    var idx = CORNER_CYCLE.indexOf(desired);
+    for (var i = 0; i < 4; i++) {
+      var candidate = CORNER_CYCLE[(idx + i) % 4];
+      var occupied = false;
+      for (var otherId in allPositions) {
+        if (otherId !== panelId && allPositions[otherId] === candidate) { occupied = true; break; }
+      }
+      if (!occupied) return candidate;
+    }
+    return desired; // all occupied (impossible with 3 panels, 4 corners)
+  }
+
+  function applyPanelPosition(id, corner) {
+    var el = document.getElementById(id);
+    if (!el) return;
+    el.setAttribute('data-position', corner);
+    var btn = el.querySelector('.panel-corner-btn');
+    if (btn) {
+      btn.textContent = CORNER_ARROWS[corner];
+      btn.setAttribute('aria-label',
+        'Move ' + (PANEL_NAMES[id] || 'panel') + ' to next corner (currently ' + CORNER_LABELS[corner] + ')');
+    }
+  }
+
+  function initPanelPositions() {
+    var positions = getPanelPositions();
+    for (var id in positions) {
+      applyPanelPosition(id, positions[id]);
+    }
+    // Wire up click handlers on corner buttons
+    var btns = document.querySelectorAll('.panel-corner-btn[data-panel]');
+    for (var i = 0; i < btns.length; i++) {
+      btns[i].addEventListener('click', function(e) {
+        e.stopPropagation();
+        var panelId = this.getAttribute('data-panel');
+        onCornerClick(panelId);
+      });
+    }
+  }
+
+  function onCornerClick(panelId) {
+    var positions = getPanelPositions();
+    var current = positions[panelId];
+    var nextIdx = (CORNER_CYCLE.indexOf(current) + 1) % 4;
+    var next = nextAvailableCorner(panelId, CORNER_CYCLE[nextIdx], positions);
+    try { localStorage.setItem('panel-corner-' + panelId, next); } catch (_) { /* quota */ }
+    applyPanelPosition(panelId, next);
+    // Announce for screen readers
+    var announce = document.getElementById('panelPositionAnnounce');
+    if (announce) announce.textContent = (PANEL_NAMES[panelId] || 'Panel') + ' moved to ' + CORNER_LABELS[next];
+  }
+
+  function resetPanelPositions() {
+    for (var id in PANEL_DEFAULTS) {
+      try { localStorage.removeItem('panel-corner-' + id); } catch (_) { /* ignore */ }
+      applyPanelPosition(id, PANEL_DEFAULTS[id]);
+    }
+  }
+
+  // Export for testing
+  if (typeof window !== 'undefined') {
+    window._panelCorner = {
+      PANEL_DEFAULTS: PANEL_DEFAULTS, CORNER_CYCLE: CORNER_CYCLE,
+      getPanelPositions: getPanelPositions, nextAvailableCorner: nextAvailableCorner,
+      applyPanelPosition: applyPanelPosition, onCornerClick: onCornerClick,
+      resetPanelPositions: resetPanelPositions
+    };
+  }
+
   function formatLiveTimestampHtml(isoLike) {
     if (typeof formatTimestampWithTooltip !== 'function' || typeof getTimestampMode !== 'function') {
       return escapeHtml(typeof timeAgo === 'function' ? timeAgo(isoLike) : '—');
@@ -112,6 +203,7 @@
 
   function vcrResumeLive() {
     stopReplay();
+    VCR.replayGen++; // invalidate any in-flight async chunk processing
     VCR.playhead = -1;
     VCR.speed = 1;
     VCR.missedCount = 0;
@@ -138,6 +230,8 @@
   function vcrReplayFromTs(targetTs) {
     const fetchFrom = new Date(targetTs).toISOString();
     stopReplay();
+    VCR.replayGen++;
+    var gen = VCR.replayGen;
     vcrSetMode('REPLAY');
 
     // Reload map nodes to match the replay time
@@ -149,7 +243,10 @@
       .then(r => r.json())
       .then(data => {
         const pkts = data.packets || [];
-        const replayEntries = expandToBufferEntries(pkts);
+        return expandToBufferEntriesAsync(pkts);
+      })
+      .then(function(replayEntries) {
+        if (gen !== VCR.replayGen) return; // stale async result — user changed mode
         if (replayEntries.length === 0) {
           vcrSetMode('PAUSED');
           return;
@@ -198,6 +295,8 @@
 
   function vcrRewind(ms) {
     stopReplay();
+    VCR.replayGen++;
+    var gen = VCR.replayGen;
     // Fetch packets from DB for the time window
     const now = Date.now();
     const from = new Date(now - ms).toISOString();
@@ -208,8 +307,11 @@
         // Prepend to buffer (avoid duplicates by ID)
         const existingIds = new Set(VCR.buffer.map(b => b.pkt.id).filter(Boolean));
         const filtered = pkts.filter(p => !existingIds.has(p.id));
-        const newEntries = expandToBufferEntries(filtered);
-        VCR.buffer = [...newEntries, ...VCR.buffer];
+        return expandToBufferEntriesAsync(filtered);
+      })
+      .then(function(newEntries) {
+        if (gen !== VCR.replayGen) return; // stale async result
+        VCR.buffer = [].concat(newEntries, VCR.buffer);
         VCR.playhead = 0;
         VCR.speed = 1;
         vcrSetMode('REPLAY');
@@ -270,15 +372,18 @@
     // Get timestamp of last packet in buffer to fetch the next page
     const last = VCR.buffer[VCR.buffer.length - 1];
     if (!last) return Promise.resolve(false);
+    var gen = VCR.replayGen;
     const since = new Date(last.ts + 1).toISOString(); // +1ms to avoid dupe
     return fetch(`/api/packets?limit=10000&grouped=false&expand=observations&since=${encodeURIComponent(since)}&order=asc`)
       .then(r => r.json())
       .then(data => {
         const pkts = data.packets || [];
         if (pkts.length === 0) return false;
-        const newEntries = expandToBufferEntries(pkts);
-        VCR.buffer = VCR.buffer.concat(newEntries);
-        return true;
+        return expandToBufferEntriesAsync(pkts).then(function(newEntries) {
+          if (gen !== VCR.replayGen) return false; // stale
+          VCR.buffer = VCR.buffer.concat(newEntries);
+          return true;
+        });
       })
       .catch(() => false);
   }
@@ -431,13 +536,14 @@
   }
 
   function dbPacketToLive(pkt) {
-    const raw = JSON.parse(pkt.decoded_json || '{}');
-    const hops = JSON.parse(pkt.path_json || '[]');
+    const raw = getParsedDecoded(pkt);
+    const hops = getParsedPath(pkt);
     const typeName = raw.type || pkt.payload_type_name || 'UNKNOWN';
     return {
       id: pkt.id, hash: pkt.hash,
       raw: pkt.raw_hex,
       path_json: pkt.path_json,
+      resolved_path: pkt.resolved_path,
       _ts: new Date(pkt.timestamp || pkt.created_at).getTime(),
       decoded: { header: { payloadTypeName: typeName }, payload: raw, path: { hops } },
       snr: pkt.snr, rssi: pkt.rssi, observer: pkt.observer_name
@@ -445,11 +551,53 @@
   }
 
   // Expand a DB packet (with optional observations[]) into VCR buffer entries
+  /**
+   * Process packets into buffer entries in chunks to avoid blocking the main thread.
+   * Returns a Promise that resolves with the entries array.
+   * Each chunk processes CHUNK_SIZE packets, then yields to the event loop via setTimeout(0).
+   */
+  var VCR_CHUNK_SIZE = 200;
+  function expandToBufferEntriesAsync(pkts) {
+    return new Promise(function(resolve) {
+      var entries = [];
+      var i = 0;
+      function processChunk() {
+        var end = Math.min(i + VCR_CHUNK_SIZE, pkts.length);
+        for (; i < end; i++) {
+          var p = pkts[i];
+          if (p.observations && p.observations.length > 0) {
+            for (var j = 0; j < p.observations.length; j++) {
+              var obs = p.observations[j];
+              entries.push({
+                ts: new Date(obs.timestamp || p.timestamp || p.created_at).getTime(),
+                pkt: dbPacketToLive(Object.assign({}, p, obs, { hash: p.hash, raw_hex: p.raw_hex, decoded_json: p.decoded_json }))
+              });
+            }
+          } else {
+            entries.push({
+              ts: new Date(p.timestamp || p.created_at).getTime(),
+              pkt: dbPacketToLive(p)
+            });
+          }
+        }
+        if (i < pkts.length) {
+          setTimeout(processChunk, 0);
+        } else {
+          resolve(entries);
+        }
+      }
+      processChunk();
+    });
+  }
+
+  // Synchronous version kept for small datasets and backward compat (tests)
   function expandToBufferEntries(pkts) {
-    const entries = [];
-    for (const p of pkts) {
+    var entries = [];
+    for (var k = 0; k < pkts.length; k++) {
+      var p = pkts[k];
       if (p.observations && p.observations.length > 0) {
-        for (const obs of p.observations) {
+        for (var j = 0; j < p.observations.length; j++) {
+          var obs = p.observations[j];
           entries.push({
             ts: new Date(obs.timestamp || p.timestamp || p.created_at).getTime(),
             pkt: dbPacketToLive(Object.assign({}, p, obs, { hash: p.hash, raw_hex: p.raw_hex, decoded_json: p.decoded_json }))
@@ -478,11 +626,18 @@
         clearTimeout(entry.timer);
       }
       propagationBuffer.clear();
+      // Batch-update timeline once on restore instead of per-packet while hidden
+      updateTimeline();
     }
   });
 
+  function packetTimestamp(pkt) {
+    return new Date(pkt.timestamp || pkt.created_at || Date.now()).getTime();
+  }
+  if (typeof window !== 'undefined') window._live_packetTimestamp = packetTimestamp;
+
   function bufferPacket(pkt) {
-    pkt._ts = Date.now();
+    pkt._ts = packetTimestamp(pkt);
     const entry = { ts: pkt._ts, pkt };
     VCR.buffer.push(entry);
     // Keep buffer capped at ~2000 — adjust playhead to avoid stale indices (#63)
@@ -497,7 +652,6 @@
     if (VCR.mode === 'LIVE') {
       // Skip animations when tab is backgrounded — just buffer for VCR timeline
       if (_tabHidden) {
-        updateTimeline();
         return;
       }
       if (realisticPropagation && pkt.hash) {
@@ -687,15 +841,26 @@
           </div>
         </div>
         <div class="live-overlay live-feed" id="liveFeed">
-          <button class="feed-hide-btn" id="feedHideBtn" title="Hide feed">✕</button>
+          <div class="panel-header">
+            <button class="panel-corner-btn" data-panel="liveFeed" title="Move panel to next corner" aria-label="Move panel to next corner">◫</button>
+            <button class="feed-hide-btn" id="feedHideBtn" title="Hide feed">✕</button>
+          </div>
+          <div class="panel-content" aria-live="polite" aria-relevant="additions" role="log"></div>
         </div>
         <button class="feed-show-btn hidden" id="feedShowBtn" title="Show feed">📋</button>
         <div class="live-overlay live-node-detail hidden" id="liveNodeDetail">
-          <button class="feed-hide-btn" id="nodeDetailClose" title="Close">✕</button>
-          <div id="nodeDetailContent"></div>
+          <div class="panel-header">
+            <button class="panel-corner-btn" data-panel="liveNodeDetail" title="Move panel to next corner" aria-label="Move panel to next corner">◫</button>
+            <button class="feed-hide-btn" id="nodeDetailClose" title="Close">✕</button>
+          </div>
+          <div class="panel-content" id="nodeDetailContent"></div>
         </div>
-        <button class="legend-toggle-btn hidden" id="legendToggleBtn" aria-label="Show legend" title="Show legend">🎨</button>
+        <button class="legend-toggle-btn" id="legendToggleBtn" aria-label="Show legend" title="Show legend">🎨</button>
         <div class="live-overlay live-legend" id="liveLegend" role="region" aria-label="Map legend">
+          <div class="panel-header">
+            <button class="panel-corner-btn" data-panel="liveLegend" title="Move panel to next corner" aria-label="Move panel to next corner">◫</button>
+          </div>
+          <div class="panel-content">
           <h3 class="legend-title">PACKET TYPES</h3>
           <ul class="legend-list">
             <li><span class="live-dot" style="background:${TYPE_COLORS.ADVERT}" aria-hidden="true"></span> Advert — Node advertisement</li>
@@ -706,9 +871,11 @@
           </ul>
           <h3 class="legend-title" style="margin-top:8px">NODE ROLES</h3>
           <ul class="legend-list" id="roleLegendList"></ul>
+          </div>
         </div>
 
         <!-- VCR Bar -->
+        <div class="sr-only" id="panelPositionAnnounce" aria-live="polite"></div>
         <div class="vcr-bar" id="vcrBar">
           <div class="vcr-controls">
             <button id="vcrRewindBtn" class="vcr-btn" title="Rewind" aria-label="Rewind">⏪</button>
@@ -975,14 +1142,25 @@
     const legendEl = document.getElementById('liveLegend');
     const legendToggleBtn = document.getElementById('legendToggleBtn');
     if (legendToggleBtn && legendEl) {
+      // Restore legend collapsed state from localStorage (#279)
+      try {
+        if (localStorage.getItem('live-legend-hidden') === 'true') {
+          legendEl.classList.add('hidden');
+          legendToggleBtn.setAttribute('aria-label', 'Show legend');
+          legendToggleBtn.textContent = '🎨';
+        }
+      } catch (_) { /* private browsing / storage disabled */ }
       legendToggleBtn.addEventListener('click', () => {
-        const isVisible = legendEl.classList.toggle('legend-mobile-visible');
-        legendToggleBtn.setAttribute('aria-label', isVisible ? 'Hide legend' : 'Show legend');
-        legendToggleBtn.textContent = isVisible ? '✕' : '🎨';
+        const nowHidden = legendEl.classList.toggle('hidden');
+        legendToggleBtn.setAttribute('aria-label', nowHidden ? 'Show legend' : 'Hide legend');
+        legendToggleBtn.textContent = nowHidden ? '🎨' : '✕';
+        try { localStorage.setItem('live-legend-hidden', String(nowHidden)); } catch (_) { /* ignore */ }
       });
     }
 
     // Populate role legend from shared roles.js
+    // Initialize panel corner positions (#608 M0)
+    initPanelPositions();
     const roleLegendList = document.getElementById('roleLegendList');
     if (roleLegendList) {
       for (const role of (window.ROLE_SORT || ['repeater', 'companion', 'room', 'sensor', 'observer'])) {
@@ -1246,7 +1424,7 @@
       let html = `
         <div style="padding:16px;">
           <div style="display:flex;align-items:center;gap:8px;margin-bottom:12px;">
-            <span class="${statusDot}" style="font-size:18px">●</span>
+            <span class="${statusDot}" style="font-size:18px" aria-hidden="true">●</span>
             <h3 style="margin:0;font-size:16px;font-weight:700;">${escapeHtml(n.name || 'Unknown')}</h3>
           </div>
           <div style="margin-bottom:12px;">
@@ -1277,7 +1455,7 @@
         html += `<h4 style="font-size:12px;margin:12px 0 6px;color:var(--text-muted);">Recent Packets</h4>
           <div style="font-size:11px;max-height:200px;overflow-y:auto;">` +
           recent.slice(0, 10).map(p => `<div style="padding:2px 0;display:flex;justify-content:space-between;">
-            <a href="#/packets/${encodeURIComponent(p.hash || '')}" style="color:var(--accent);text-decoration:none;">${escapeHtml(p.payload_type || '?')}${p.observation_count > 1 ? ' <span class="badge badge-obs" style="font-size:9px">👁 ' + p.observation_count + '</span>' : ''}</a>
+            <a href="#/packets/${encodeURIComponent(p.hash || '')}" style="color:var(--accent);text-decoration:none;">${escapeHtml(p.payload_type || '?')}${transportBadge(p.route_type)}${p.observation_count > 1 ? ' <span class="badge badge-obs" style="font-size:9px">👁 ' + p.observation_count + '</span>' : ''}</a>
             <span style="color:var(--text-muted)">${formatLiveTimestampHtml(p.timestamp)}</span>
           </div>`).join('') +
           '</div>';
@@ -1350,9 +1528,29 @@
       const _el2 = document.getElementById('liveNodeCount'); if (_el2) _el2.textContent = Object.keys(nodeMarkers).length;
       // Initialize shared HopResolver with loaded nodes
       if (window.HopResolver) HopResolver.init(list);
+      // Fetch affinity data for hop disambiguation
+      fetchAffinityData();
+      startAffinityRefresh();
     } catch (e) { console.error('Failed to load nodes:', e); }
   }
 
+  let _affinityInterval = null;
+
+  async function fetchAffinityData() {
+    try {
+      const resp = await fetch('/api/analytics/neighbor-graph');
+      const graph = await resp.json();
+      if (window.HopResolver && HopResolver.setAffinity) {
+        HopResolver.setAffinity(graph);
+      }
+    } catch (e) { console.warn('Failed to fetch affinity data:', e); }
+  }
+
+  function startAffinityRefresh() {
+    if (_affinityInterval) clearInterval(_affinityInterval);
+    _affinityInterval = setInterval(fetchAffinityData, 60000);
+  }
+
   function clearNodeMarkers() {
     if (nodesLayer) nodesLayer.clearLayers();
     if (animLayer) animLayer.clearLayers();
@@ -1405,7 +1603,9 @@
   function rebuildFeedList() {
     const feed = document.getElementById('liveFeed');
     if (!feed) return;
-    feed.querySelectorAll('.live-feed-item').forEach(el => el.remove());
+    const feedContent = feed.querySelector('.panel-content');
+    if (!feedContent) return;
+    feedContent.querySelectorAll('.live-feed-item').forEach(el => el.remove());
     feedDedup.clear();
 
     // Aggregate VCR buffer by hash, then create one feed item per unique hash
@@ -1440,7 +1640,7 @@
       for (const op of group.packets) {
         let opHops = [];
         if (op.path_json) {
-          try { opHops = typeof op.path_json === 'string' ? JSON.parse(op.path_json) : op.path_json; } catch {}
+          try { opHops = getParsedPath(op); } catch {}
         } else if (op.decoded?.path?.hops) {
           opHops = op.decoded.path.hops;
         }
@@ -1453,6 +1653,10 @@
       const hopStr = longestHops.length ? `<span class="feed-hops">${longestHops.length}⇢</span>` : '';
       const obsBadge = group.count > 1 ? `<span class="badge badge-obs" style="font-size:10px;margin-left:4px">👁 ${group.count}</span>` : '';
 
+      var _ccPayload = (pkt.decoded || {}).payload || {};
+      var _ccChan1 = (typeName === 'GRP_TXT' || typeName === 'CHAN') ? (_ccPayload.channel || null) : null;
+      var dotHtml1 = _ccChan1 ? _feedColorDot(_ccChan1) : '';
+
       const item = document.createElement('div');
       item.className = 'live-feed-item';
       item.setAttribute('tabindex', '0');
@@ -1462,12 +1666,13 @@
       item.innerHTML = `
         <span class="feed-icon" style="color:${color}">${icon}</span>
         <span class="feed-type" style="color:${color}">${typeName}</span>
-        ${hopStr}${obsBadge}
+        ${dotHtml1}${transportBadge(pkt.route_type)}${hopStr}${obsBadge}
         <span class="feed-text">${escapeHtml(preview)}</span>
         <span class="feed-time">${formatLiveTimestampHtml(group.latestTs || Date.now())}</span>
       `;
+      if (_ccChan1) item._ccChannel = _ccChan1; // channel color picker (#674)
       item.addEventListener('click', () => showFeedCard(item, pkt, color));
-      feed.appendChild(item);
+      feedContent.appendChild(item);
 
       // Register in dedup map so replay and live updates work
       if (group.hash) {
@@ -1564,6 +1769,7 @@
           }
           delete nodeMarkers[key];
           delete nodeData[key];
+          delete nodeActivity[key];
           pruned = true;
         }
       } else if (marker && marker._staleDimmed) {
@@ -1579,30 +1785,43 @@
       if (_el2) _el2.textContent = Object.keys(nodeMarkers).length;
       if (window.HopResolver) HopResolver.init(Object.values(nodeData));
     }
+    // Prune orphaned nodeActivity entries (nodes removed above or never tracked)
+    for (var aKey in nodeActivity) {
+      if (!(aKey in nodeData)) delete nodeActivity[aKey];
+    }
   }
 
   // Expose for testing
   window._livePruneStaleNodes = pruneStaleNodes;
   window._liveNodeMarkers = function() { return nodeMarkers; };
   window._liveNodeData = function() { return nodeData; };
+  window._liveNodeActivity = function() { return nodeActivity; };
   window._vcrFormatTime = vcrFormatTime;
+  window._liveDbPacketToLive = dbPacketToLive;
+  window._liveExpandToBufferEntries = expandToBufferEntries;
+  window._liveExpandToBufferEntriesAsync = expandToBufferEntriesAsync;
+  window._liveSEG_MAP = SEG_MAP;
+  window._liveBufferPacket = bufferPacket;
+  window._liveVCR = function() { return VCR; };
+  window._liveGetFavoritePubkeys = getFavoritePubkeys;
+  window._livePacketInvolvesFavorite = packetInvolvesFavorite;
+  window._liveIsNodeFavorited = isNodeFavorited;
+  window._liveFormatLiveTimestampHtml = formatLiveTimestampHtml;
+  window._liveResolveHopPositions = resolveHopPositions;
+  window._liveVcrSpeedCycle = vcrSpeedCycle;
+  window._liveVcrPause = vcrPause;
+  window._liveVcrResumeLive = vcrResumeLive;
+  window._liveVcrSetMode = vcrSetMode;
 
   async function replayRecent() {
     try {
-      const resp = await fetch('/api/packets?limit=8&groupByHash=true');
+      // Single bulk fetch with expand=observations — no N+1 calls
+      const resp = await fetch('/api/packets?limit=8&expand=observations');
       const data = await resp.json();
       const groups = (data.packets || []).reverse();
 
-      // Fetch all observations first, then stagger rendering
-      const allGroups = [];
-      for (let i = 0; i < groups.length; i++) {
-        const group = groups[i];
-        let observations = [];
-        try {
-          const detail = await fetch('/api/packets/' + encodeURIComponent(group.hash));
-          const detailData = await detail.json();
-          observations = detailData.observations || [];
-        } catch {}
+      const allGroups = groups.map((group) => {
+        const observations = group.observations || [];
 
         const livePackets = observations.map(obs => {
           const livePkt = dbPacketToLive(Object.assign({}, group, obs, {
@@ -1621,8 +1840,8 @@
         }
 
         livePackets.forEach(lp => VCR.buffer.push({ ts: lp._ts, pkt: lp }));
-        allGroups.push(livePackets);
-      }
+        return livePackets;
+      });
 
       // Render with real timing gaps between packets
       // Sort by earliest timestamp
@@ -1710,7 +1929,7 @@
       for (const fp of packets) {
         let fpHops = [];
         if (fp.path_json) {
-          try { fpHops = typeof fp.path_json === 'string' ? JSON.parse(fp.path_json) : fp.path_json; } catch {}
+          try { fpHops = getParsedPath(fp); } catch {}
         } else if (fp.decoded?.path?.hops) {
           fpHops = fp.decoded.path.hops;
         }
@@ -1747,14 +1966,14 @@
       var qp = qd.payload || {};
       var hops;
       if (qpkt.path_json) {
-        try { hops = typeof qpkt.path_json === 'string' ? JSON.parse(qpkt.path_json) : qpkt.path_json; } catch (e) { hops = qd.path?.hops || []; }
+        try { hops = getParsedPath(qpkt); } catch (e) { hops = qd.path?.hops || []; }
       } else {
         hops = qd.path?.hops || [];
       }
       var pathKey = hops.join(',');
       if (seenPathKeys.has(pathKey)) continue;
       seenPathKeys.add(pathKey);
-      var hopPositions = resolveHopPositions(hops, qp);
+      var hopPositions = resolveHopPositions(hops, qp, window.getResolvedPath ? getResolvedPath(qpkt) : null);
       if (hopPositions.length >= 2) {
         allPaths.push({ hopPositions: hopPositions, raw: qpkt.raw || first.raw });
       } else if (hopPositions.length === 1) {
@@ -1787,19 +2006,83 @@
         }
       }
       firstPathDone = true;
-      animatePath(allPaths[ai].hopPositions, typeName, color, allPaths[ai].raw, onHop);
+      // For TRACE packets, split at hopsCompleted: solid for completed, dashed for remaining
+      var hopsCompleted = decoded.path && decoded.path.hopsCompleted;
+      if (typeName === 'TRACE' && hopsCompleted != null && hopsCompleted < allPaths[ai].hopPositions.length) {
+        var completedPositions = allPaths[ai].hopPositions.slice(0, hopsCompleted + 1);
+        var remainingPositions = allPaths[ai].hopPositions.slice(hopsCompleted);
+        if (completedPositions.length >= 2) {
+          animatePath(completedPositions, typeName, color, allPaths[ai].raw, onHop);
+        } else if (completedPositions.length === 1) {
+          pulseNode(completedPositions[0].key, completedPositions[0].pos, typeName);
+        }
+        if (remainingPositions.length >= 2) {
+          drawDashedPath(remainingPositions, color);
+        }
+      } else {
+        animatePath(allPaths[ai].hopPositions, typeName, color, allPaths[ai].raw, onHop);
+      }
     }
   }
 
-  function resolveHopPositions(hops, payload) {
-    // Delegate to shared HopResolver (from hop-resolver.js) instead of reimplementing
-    const originLat = payload.lat != null && !(payload.lat === 0 && payload.lon === 0) ? payload.lat : null;
-    const originLon = payload.lon != null && !(payload.lon === 0 && payload.lon === 0) ? payload.lon : null;
+  // Draw a static dashed/ghosted line for unreached TRACE hops
+  function drawDashedPath(hopPositions, color) {
+    var GHOST_TIMEOUT_MS = 10000;
+    var ghostColor = getComputedStyle(document.documentElement).getPropertyValue('--trace-ghost-color').trim() || '#94a3b8';
+    if (!pathsLayer) return;
+    for (var i = 0; i < hopPositions.length - 1; i++) {
+      var from = hopPositions[i].pos;
+      var to = hopPositions[i + 1].pos;
+      var line = L.polyline([from, to], {
+        color: color, weight: 2, opacity: 0.25, dashArray: '6, 8'
+      }).addTo(pathsLayer);
+      // Pulse the unreached hop nodes as ghost markers
+      if (i > 0) {
+        var hp = hopPositions[i];
+        if (!nodeMarkers[hp.key]) {
+          var ghost = L.circleMarker(hp.pos, {
+            radius: 3, fillColor: ghostColor, fillOpacity: 0.2, color: color, weight: 1, opacity: 0.3
+          }).addTo(pathsLayer);
+          setTimeout((function(g) { return function() { if (pathsLayer.hasLayer(g)) pathsLayer.removeLayer(g); }; })(ghost), GHOST_TIMEOUT_MS);
+        }
+      }
+      // Remove dashed line after timeout
+      setTimeout((function(l) { return function() { if (pathsLayer.hasLayer(l)) pathsLayer.removeLayer(l); }; })(line), GHOST_TIMEOUT_MS);
+    }
+    // Ghost marker for the final unreached hop
+    var last = hopPositions[hopPositions.length - 1];
+    if (!nodeMarkers[last.key]) {
+      var ghostEnd = L.circleMarker(last.pos, {
+        radius: 4, fillColor: ghostColor, fillOpacity: 0.25, color: color, weight: 1, opacity: 0.35
+      }).addTo(pathsLayer);
+      setTimeout(function() { if (pathsLayer.hasLayer(ghostEnd)) pathsLayer.removeLayer(ghostEnd); }, GHOST_TIMEOUT_MS);
+    }
+  }
 
-    // Use HopResolver if available and initialized, otherwise fall back to simple lookup
-    const resolvedMap = (window.HopResolver && HopResolver.ready())
-      ? HopResolver.resolve(hops, originLat, originLon, null, null, null)
-      : {};
+  function resolveHopPositions(hops, payload, resolvedPath) {
+    // Hoist sender GPS guard once — reject (0,0) as "no GPS"
+    const hasValidGps = payload.lat != null && payload.lon != null
+      && !(payload.lat === 0 && payload.lon === 0);
+    const senderLat = hasValidGps ? payload.lat : null;
+    const senderLon = hasValidGps ? payload.lon : null;
+
+    // Prefer server-side resolved_path when available
+    var resolvedMap;
+    if (resolvedPath && resolvedPath.length === hops.length && window.HopResolver && HopResolver.ready()) {
+      resolvedMap = HopResolver.resolveFromServer(hops, resolvedPath);
+      // Fill in any null entries from client-side fallback, preserving sender GPS context
+      var nullHops = hops.filter(function(h, i) { return !resolvedPath[i] && !resolvedMap[h]; });
+      if (nullHops.length) {
+        var fallback = HopResolver.resolve(nullHops, senderLat, senderLon, null, null, null);
+        for (var k in fallback) resolvedMap[k] = fallback[k];
+      }
+    } else {
+      // Delegate to shared HopResolver (from hop-resolver.js) instead of reimplementing
+      // Use HopResolver if available and initialized, otherwise fall back to simple lookup
+      resolvedMap = (window.HopResolver && HopResolver.ready())
+        ? HopResolver.resolve(hops, senderLat, senderLon, null, null, null)
+        : {};
+    }
 
     // Convert HopResolver's map format to the array format live.js expects: {key, pos, name, known}
     const raw = hops.map(hop => {
@@ -1816,7 +2099,7 @@
     });
 
     // Add sender position as anchor if available
-    if (payload.pubKey && originLat != null) {
+    if (payload.pubKey && senderLat != null) {
       const existing = raw.find(p => p.key === payload.pubKey);
       if (!existing) {
         raw.unshift({ key: payload.pubKey, pos: [payload.lat, payload.lon], name: payload.name || payload.pubKey.slice(0, 8), known: true });
@@ -1934,6 +2217,7 @@
     let lastPulse = performance.now();
     const pulseStart = lastPulse;
     function animatePulse(now) {
+      if (!animLayer) return;
       if (now - pulseStart > 2000) {
         try { animLayer.removeLayer(ring); } catch {}
         return;
@@ -2178,6 +2462,10 @@
     const startTime = performance.now();
 
     function tick(now) {
+      if (!animLayer || !pathsLayer) {
+        if (onComplete) onComplete();
+        return;
+      }
       const elapsed = now - startTime;
       const t = Math.min(1, elapsed / DURATION_MS);
       const lat = from[0] + (to[0] - from[0]) * t;
@@ -2222,6 +2510,11 @@
         // Fade out
         const fadeStart = performance.now();
         function fadeOut(now) {
+          if (!animLayer || !pathsLayer) {
+            charMarkers.length = 0;
+            if (onComplete) onComplete();
+            return;
+          }
           const ft = Math.min(1, (now - fadeStart) / 300);
           if (ft >= 1) {
             for (const cm of charMarkers) try { animLayer.removeLayer(cm.marker); } catch {}
@@ -2269,6 +2562,10 @@
 
     let lastStep = performance.now();
     function animateLine(now) {
+      if (!animLayer || !pathsLayer) {
+        if (onComplete) onComplete();
+        return;
+      }
       const elapsed = now - lastStep;
       if (elapsed >= 33) {
         const ticks = Math.min(Math.floor(elapsed / 33), 4);
@@ -2297,6 +2594,7 @@
             let fadeOp = mainOpacity;
             let lastFade = performance.now();
             function animateFade(now) {
+              if (!pathsLayer) return;
               const fadeElapsed = now - lastFade;
               if (fadeElapsed >= 52) {
                 const fadeTicks = Math.min(Math.floor(fadeElapsed / 52), 4);
@@ -2355,23 +2653,52 @@
     if (heatLayer) { map.removeLayer(heatLayer); heatLayer = null; }
   }
 
+  /** Extract channel row style from a packet (shared by feed item builders). */
+  function _getChannelStyle(pkt) {
+    if (!window.ChannelColors) return '';
+    var d = pkt.decoded || {};
+    var p = d.payload || {};
+    var typeName = p.type || (d.header || {}).payloadTypeName || '';
+    var ch = p.channel || null;
+    return window.ChannelColors.getRowStyle(typeName, ch);
+  }
+
+  /** Build a clickable 12×12 color dot for a channel feed item (#674). */
+  function _feedColorDot(channel) {
+    if (!channel || !window.ChannelColors) return '';
+    var c = window.ChannelColors.get(channel);
+    var bg = c || 'transparent';
+    var border = c ? c : 'var(--border-color, #555)';
+    var style = c
+      ? 'background:' + bg + ';border:1px solid ' + border
+      : 'background:transparent;border:1px dashed ' + border;
+    return '<span class="feed-color-dot" data-channel="' + escapeHtml(channel) + '" style="display:inline-block;width:12px;height:12px;border-radius:50%;' + style + ';cursor:pointer;vertical-align:middle;margin-left:4px;flex-shrink:0" title="Set color for ' + escapeHtml(channel) + '"></span>';
+  }
+
   function addFeedItemDOM(icon, typeName, payload, hops, color, pkt, feed) {
     const text = payload.text || payload.name || '';
     const preview = text ? ' ' + (text.length > 35 ? text.slice(0, 35) + '…' : text) : '';
     const hopStr = hops.length ? `<span class="feed-hops">${hops.length}⇢</span>` : '';
     const obsBadge = pkt.observation_count > 1 ? `<span class="badge badge-obs" style="font-size:10px;margin-left:4px">👁 ${pkt.observation_count}</span>` : '';
+    var _ccPayload2 = (pkt.decoded || {}).payload || {};
+    var _ccChan = (typeName === 'GRP_TXT' || typeName === 'CHAN') ? (_ccPayload2.channel || null) : null;
+    var dotHtml = _ccChan ? _feedColorDot(_ccChan) : '';
     const item = document.createElement('div');
     item.className = 'live-feed-item';
     item.setAttribute('tabindex', '0');
     item.setAttribute('role', 'button');
     item.style.cursor = 'pointer';
+    // Channel color highlighting for GRP_TXT packets (#271)
+    var _cs = _getChannelStyle(pkt);
+    if (_cs) item.style.cssText += _cs;
     item.innerHTML = `
       <span class="feed-icon" style="color:${color}">${icon}</span>
       <span class="feed-type" style="color:${color}">${typeName}</span>
-      ${hopStr}${obsBadge}
+      ${dotHtml}${transportBadge(pkt.route_type)}${hopStr}${obsBadge}
       <span class="feed-text">${escapeHtml(preview)}</span>
       <span class="feed-time">${formatLiveTimestampHtml(pkt._ts || Date.now())}</span>
     `;
+    if (_ccChan) item._ccChannel = _ccChan; // channel color picker (#674)
     item.addEventListener('click', () => showFeedCard(item, pkt, color));
     feed.appendChild(item);
   }
@@ -2384,7 +2711,8 @@
   const DEDUP_WINDOW = 30000;
 
   function addFeedItem(icon, typeName, payload, hops, color, pkt) {
-    const feed = document.getElementById('liveFeed');
+    const feedPanel = document.getElementById('liveFeed');
+    const feed = feedPanel ? feedPanel.querySelector('.panel-content') : null;
     if (!feed) return;
     if (showOnlyFavorites && !packetInvolvesFavorite(pkt)) return;
 
@@ -2426,6 +2754,9 @@
     const preview = text ? ' ' + (text.length > 35 ? text.slice(0, 35) + '…' : text) : '';
     const hopStr = hops.length ? `<span class="feed-hops">${hops.length}⇢</span>` : '';
     const obsBadge = incomingObs > 1 ? `<span class="badge badge-obs" style="font-size:10px;margin-left:4px">👁 ${incomingObs}</span>` : '';
+    var _ccPayload3 = (pkt.decoded || {}).payload || {};
+    var _ccChan3 = (typeName === 'GRP_TXT' || typeName === 'CHAN') ? (_ccPayload3.channel || null) : null;
+    var dotHtml3 = _ccChan3 ? _feedColorDot(_ccChan3) : '';
 
     const item = document.createElement('div');
     item.className = 'live-feed-item live-feed-enter';
@@ -2433,13 +2764,17 @@
     item.setAttribute('role', 'button');
     if (hash) item.setAttribute('data-hash', hash);
     item.style.cursor = 'pointer';
+    // Channel color highlighting for GRP_TXT packets (#271)
+    var _chanStyle = _getChannelStyle(pkt);
+    if (_chanStyle) item.style.cssText += _chanStyle;
     item.innerHTML = `
       <span class="feed-icon" style="color:${color}">${icon}</span>
       <span class="feed-type" style="color:${color}">${typeName}</span>
-      ${hopStr}${obsBadge}
+      ${dotHtml3}${transportBadge(pkt.route_type)}${hopStr}${obsBadge}
       <span class="feed-text">${escapeHtml(preview)}</span>
       <span class="feed-time">${formatLiveTimestampHtml(pkt._ts || Date.now())}</span>
     `;
+    if (_ccChan3) item._ccChannel = _ccChan3; // channel color picker (#674)
     item.addEventListener('click', () => showFeedCard(item, pkt, color));
     feed.prepend(item);
     requestAnimationFrame(() => requestAnimationFrame(() => item.classList.remove('live-feed-enter')));
@@ -2514,6 +2849,7 @@
     if (_lcdClockInterval) { clearInterval(_lcdClockInterval); _lcdClockInterval = null; }
     if (_rateCounterInterval) { clearInterval(_rateCounterInterval); _rateCounterInterval = null; }
     if (_pruneInterval) { clearInterval(_pruneInterval); _pruneInterval = null; }
+    if (_affinityInterval) { clearInterval(_affinityInterval); _affinityInterval = null; }
     if (ws) { ws.onclose = null; ws.close(); ws = null; }
     if (map) { map.remove(); map = null; }
     if (_onResize) {
@@ -2546,7 +2882,7 @@
     packetCount = 0; activeAnims = 0;
     nodeActivity = {}; pktTimestamps = [];
     feedDedup.clear();
-    VCR.buffer = []; VCR.playhead = -1; VCR.mode = 'LIVE'; VCR.missedCount = 0; VCR.speed = 1;
+    VCR.buffer = []; VCR.playhead = -1; VCR.mode = 'LIVE'; VCR.missedCount = 0; VCR.speed = 1; VCR.replayGen = 0;
   }
 
   let _themeRefreshHandler = null;
@@ -2558,7 +2894,10 @@
         if (activeNodeDetailKey) showNodeDetail(activeNodeDetailKey);
       };
       window.addEventListener('theme-refresh', _themeRefreshHandler);
-      return init(app, routeParam);
+      var result = init(app, routeParam);
+      // Install channel color picker (M2, #271)
+      if (window.ChannelColorPicker) window.ChannelColorPicker.installLiveFeed();
+      return result;
     },
     destroy: function() {
       if (_themeRefreshHandler) { window.removeEventListener('theme-refresh', _themeRefreshHandler); _themeRefreshHandler = null; }

public/map.js

@@ -9,12 +9,14 @@
   let nodes = [];
   let targetNodeKey = null;
   let observers = [];
-  let filters = { repeater: true, companion: true, room: true, sensor: true, observer: true, lastHeard: '30d', neighbors: false, clusters: false, hashLabels: localStorage.getItem('meshcore-map-hash-labels') !== 'false', statusFilter: localStorage.getItem('meshcore-map-status-filter') || 'all' };
+  let filters = { repeater: true, companion: true, room: true, sensor: true, observer: true, lastHeard: '30d', neighbors: false, clusters: false, hashLabels: localStorage.getItem('meshcore-map-hash-labels') !== 'false', statusFilter: localStorage.getItem('meshcore-map-status-filter') || 'all', byteSize: localStorage.getItem('meshcore-map-byte-filter') || 'all' };
   let selectedReferenceNode = null;  // pubkey of the reference node for neighbor filtering
   let neighborPubkeys = null;        // Set of pubkeys that are direct neighbors of selected node
   let wsHandler = null;
   let heatLayer = null;
   let geoFilterLayer = null;
+  let affinityLayer = null;
+  let affinityData = null;
   let userHasMoved = false;
   let controlsCollapsed = false;
 
@@ -92,6 +94,15 @@
             <legend class="mc-label">Node Types</legend>
             <div id="mcRoleChecks"></div>
           </fieldset>
+          <fieldset class="mc-section">
+            <legend class="mc-label">Byte Size</legend>
+            <div class="filter-group" id="mcByteFilter">
+              <button class="btn ${filters.byteSize==='all'?'active':''}" data-byte="all">All</button>
+              <button class="btn ${filters.byteSize==='1'?'active':''}" data-byte="1">1-byte</button>
+              <button class="btn ${filters.byteSize==='2'?'active':''}" data-byte="2">2-byte</button>
+              <button class="btn ${filters.byteSize==='3'?'active':''}" data-byte="3">3-byte</button>
+            </div>
+          </fieldset>
           <fieldset class="mc-section">
             <legend class="mc-label">Display</legend>
             <label for="mcClusters"><input type="checkbox" id="mcClusters"> Show clusters</label>
@@ -112,6 +123,7 @@
             <label for="mcNeighbors"><input type="checkbox" id="mcNeighbors"> Show direct neighbors</label>
             <div id="mcNeighborRef" style="display:none;font-size:11px;color:var(--text-muted);margin-top:2px;padding-left:20px;">Ref: <span id="mcNeighborRefName">—</span></div>
             <div id="mcNeighborHint" style="display:none;font-size:11px;color:var(--text-muted);margin-top:2px;padding-left:20px;">Click a node marker to set the reference node</div>
+            <label id="mcAffinityDebugLabel" for="mcAffinityDebug" style="display:none"><input type="checkbox" id="mcAffinityDebug"> 🔍 Affinity Debug</label>
           </fieldset>
           <fieldset class="mc-section">
             <legend class="mc-label">Last Heard</legend>
@@ -178,11 +190,17 @@
     });
 
     map.on('zoomend', () => {
-      if (!_renderingMarkers) renderMarkers();
+      clearTimeout(_zoomResizeTimer);
+      _zoomResizeTimer = setTimeout(() => {
+        if (!_renderingMarkers) _repositionMarkers();
+      }, 150);
     });
 
     map.on('resize', () => {
-      if (!_renderingMarkers) renderMarkers();
+      clearTimeout(_zoomResizeTimer);
+      _zoomResizeTimer = setTimeout(() => {
+        if (!_renderingMarkers) _repositionMarkers();
+      }, 150);
     });
 
     markerLayer = L.layerGroup().addTo(map);
@@ -225,6 +243,22 @@
       renderMarkers();
     });
 
+    // Affinity Debug overlay toggle — shown only when debugAffinity config is on or localStorage override
+    (function initAffinityDebug() {
+      var label = document.getElementById('mcAffinityDebugLabel');
+      var show = (window.CLIENT_CONFIG && window.CLIENT_CONFIG.debugAffinity) || localStorage.getItem('meshcore-affinity-debug') === 'true';
+      if (show && label) label.style.display = '';
+      var cb = document.getElementById('mcAffinityDebug');
+      if (!cb) return;
+      cb.addEventListener('change', function (e) {
+        if (e.target.checked) {
+          loadAffinityDebugOverlay();
+        } else {
+          clearAffinityOverlay();
+        }
+      });
+    })();
+
     // Hash Labels toggle
     const hashLabelEl = document.getElementById('mcHashLabels');
     if (hashLabelEl) {
@@ -243,6 +277,16 @@
       });
     });
 
+    // Byte size filter buttons
+    document.querySelectorAll('#mcByteFilter .btn').forEach(btn => {
+      btn.addEventListener('click', () => {
+        filters.byteSize = btn.dataset.byte;
+        localStorage.setItem('meshcore-map-byte-filter', filters.byteSize);
+        document.querySelectorAll('#mcByteFilter .btn').forEach(b => b.classList.toggle('active', b.dataset.byte === filters.byteSize));
+        renderMarkers();
+      });
+    });
+
     // Geo filter overlay
     (async function () {
       try {
@@ -593,6 +637,8 @@
 
   var _renderingMarkers = false;
   var _lastDeconflictZoom = null;
+  var _currentMarkerData = []; // stored marker data for zoom-only repositioning
+  var _zoomResizeTimer = null;
 
   function deconflictLabels(markers, mapRef) {
     const placed = [];
@@ -643,6 +689,62 @@
     }
   }
 
+  /**
+   * Create, update, or remove the offset indicator (dashed line + dot at true GPS position)
+   * for a deconflicted marker. Shared by _renderMarkersInner and _repositionMarkers.
+   * @param {Object} m - marker data object with latLng, adjustedLatLng, offset, _leafletLine, _leafletDot
+   * @param {L.LayerGroup} layer - layer group to add/remove indicators from
+   */
+  function _updateOffsetIndicator(m, layer) {
+    var pos = m.adjustedLatLng || m.latLng;
+    var redColor = getComputedStyle(document.documentElement).getPropertyValue('--status-red').trim() || '#ef4444';
+
+    if (m.offset > 10) {
+      // Line from true position to adjusted position
+      if (m._leafletLine) {
+        m._leafletLine.setLatLngs([m.latLng, pos]);
+      } else {
+        m._leafletLine = L.polyline([m.latLng, pos], {
+          color: redColor, weight: 2, dashArray: '6,4', opacity: 0.85
+        });
+        layer.addLayer(m._leafletLine);
+      }
+      // Dot at true GPS position
+      if (!m._leafletDot) {
+        m._leafletDot = L.circleMarker(m.latLng, {
+          radius: 3, fillColor: redColor, fillOpacity: 0.9, stroke: true, color: '#fff', weight: 1
+        });
+        layer.addLayer(m._leafletDot);
+      }
+    } else {
+      // No offset — remove indicator if it existed
+      if (m._leafletLine) { layer.removeLayer(m._leafletLine); m._leafletLine = null; }
+      if (m._leafletDot) { layer.removeLayer(m._leafletDot); m._leafletDot = null; }
+    }
+  }
+
+  /**
+   * Reposition existing markers by re-running deconfliction at the current zoom.
+   * Avoids clearing and rebuilding all markers — eliminates flicker on zoom/resize.
+   */
+  function _repositionMarkers() {
+    if (!map || _currentMarkerData.length === 0) return;
+    map.invalidateSize({ animate: false });
+
+    // Re-run deconfliction with current zoom pixel coordinates
+    deconflictLabels(_currentMarkerData, map);
+
+    for (var i = 0; i < _currentMarkerData.length; i++) {
+      var m = _currentMarkerData[i];
+      var pos = m.adjustedLatLng || m.latLng;
+
+      // Update marker position
+      if (m._leafletMarker) m._leafletMarker.setLatLng(pos);
+
+      _updateOffsetIndicator(m, markerLayer);
+    }
+  }
+
   function renderMarkers() {
     if (_renderingMarkers) return;
     _renderingMarkers = true;
@@ -651,10 +753,16 @@
 
   function _renderMarkersInner() {
     markerLayer.clearLayers();
+    _currentMarkerData = [];
 
     const filtered = nodes.filter(n => {
       if (!n.lat || !n.lon) return false;
       if (!filters[n.role || 'companion']) return false;
+      // Byte size filter (applies only to repeaters)
+      if (filters.byteSize !== 'all' && (n.role || 'companion') === 'repeater') {
+        const hs = n.hash_size || 1;
+        if (String(hs) !== filters.byteSize) return false;
+      }
       // Status filter
       if (filters.statusFilter !== 'all') {
         const role = (n.role || 'companion').toLowerCase();
@@ -700,24 +808,20 @@
       deconflictLabels(allMarkers, map);
     }
 
+    // Store marker data for zoom/resize repositioning (avoids full rebuild)
+    _currentMarkerData = allMarkers;
+
     for (const m of allMarkers) {
       const pos = m.adjustedLatLng || m.latLng;
       const marker = L.marker(pos, { icon: m.icon, alt: m.alt });
       marker._nodeKey = m.node.public_key || m.node.id || null;
       marker.bindPopup(m.popupFn(), { maxWidth: 280 });
       markerLayer.addLayer(marker);
+      m._leafletMarker = marker;
+      m._leafletLine = null;
+      m._leafletDot = null;
 
-      if (m.offset > 10) {
-        const line = L.polyline([m.latLng, pos], {
-          color: getComputedStyle(document.documentElement).getPropertyValue('--status-red').trim() || '#ef4444', weight: 2, dashArray: '6,4', opacity: 0.85
-        });
-        markerLayer.addLayer(line);
-        // Small dot at true GPS position
-        const dot = L.circleMarker(m.latLng, {
-          radius: 3, fillColor: getComputedStyle(document.documentElement).getPropertyValue('--status-red').trim() || '#ef4444', fillOpacity: 0.9, stroke: true, color: '#fff', weight: 1
-        });
-        markerLayer.addLayer(dot);
-      }
+      _updateOffsetIndicator(m, markerLayer);
     }
   }
 
@@ -749,21 +853,30 @@
     selectedReferenceNode = pubkey;
     neighborPubkeys = new Set();
     try {
-      const data = await api('/nodes/' + pubkey + '/paths');
-      const paths = data.paths || [];
-      for (const p of paths) {
-        const hops = p.hops || [];
-        // Find the reference node in the path; direct neighbors are adjacent hops
-        for (let i = 0; i < hops.length; i++) {
-          if (hops[i].pubkey === pubkey) {
-            if (i > 0 && hops[i - 1].pubkey) neighborPubkeys.add(hops[i - 1].pubkey);
-            if (i < hops.length - 1 && hops[i + 1].pubkey) neighborPubkeys.add(hops[i + 1].pubkey);
+      // Use affinity-based neighbor API (server-side disambiguation) instead of
+      // client-side path walking which fails on hash collisions (#484)
+      const data = await api('/nodes/' + pubkey + '/neighbors?min_count=3');
+      for (const n of (data.neighbors || [])) {
+        if (n.pubkey) neighborPubkeys.add(n.pubkey);
+        // For ambiguous edges, include all candidates (better to show extra than miss)
+        if (n.candidates) n.candidates.forEach(function(c) { if (c.pubkey) neighborPubkeys.add(c.pubkey); });
+      }
+      // If affinity data is insufficient, fall back to client-side path walking
+      if (neighborPubkeys.size === 0) {
+        const pathData = await api('/nodes/' + pubkey + '/paths');
+        const paths = pathData.paths || [];
+        for (const p of paths) {
+          const hops = p.hops || [];
+          for (var i = 0; i < hops.length; i++) {
+            if (hops[i].pubkey === pubkey) {
+              if (i > 0 && hops[i - 1].pubkey) neighborPubkeys.add(hops[i - 1].pubkey);
+              if (i < hops.length - 1 && hops[i + 1].pubkey) neighborPubkeys.add(hops[i + 1].pubkey);
+            }
           }
         }
-        // (Redundant block removed — the main loop above already handles first/last hops)
       }
     } catch (e) {
-      console.warn('Failed to fetch neighbor paths for', pubkey, '— neighbor filter may be incomplete:', e);
+      console.warn('Failed to fetch neighbors for', pubkey, ':', e);
       neighborPubkeys = new Set();
     }
     // Update sidebar UI
@@ -779,8 +892,17 @@
     if (cb) cb.checked = true;
     renderMarkers();
   }
-  // Expose for popup onclick
+  // Event delegation for Show Neighbors links (avoids inline onclick / global function timing issues)
+  document.addEventListener('click', function(e) {
+    var link = e.target.closest('[data-show-neighbors]');
+    if (link) {
+      e.preventDefault();
+      selectReferenceNode(link.dataset.pubkey, link.dataset.name);
+    }
+  });
+  // Expose for testing
   window._mapSelectRefNode = selectReferenceNode;
+  window._mapGetNeighborPubkeys = function() { return neighborPubkeys ? Array.from(neighborPubkeys) : []; };
 
   function buildPopup(node) {
     const key = node.public_key ? truncate(node.public_key, 16) : '—';
@@ -809,7 +931,7 @@
         </dl>
         <div style="margin-top:8px;clear:both;">
           <a href="#/nodes/${node.public_key}" style="color:var(--accent);font-size:12px;">View Node →</a>
-          ${node.public_key ? ` · <a href="#" onclick="event.preventDefault();window._mapSelectRefNode('${safeEsc(node.public_key.replace(/\\/g, '\\\\').replace(/'/g, "\\'").replace(/</g, '\\x3c'))}','${safeEsc((node.name || 'Unknown').replace(/\\/g, '\\\\').replace(/'/g, "\\'").replace(/</g, '\\x3c'))}')" style="color:var(--accent);font-size:12px;">Show Neighbors</a>` : ''}
+          ${node.public_key ? ` · <a href="#" data-show-neighbors data-pubkey="${escapeHtml(node.public_key)}" data-name="${escapeHtml(node.name || 'Unknown')}" style="color:var(--accent);font-size:12px;">Show Neighbors</a>` : ''}
         </div>
       </div>`;
   }
@@ -833,12 +955,14 @@
       map = null;
     }
     markerLayer = null;
+    _currentMarkerData = [];
     routeLayer = null;
     if (heatLayer) { heatLayer = null; }
     geoFilterLayer = null;
     selectedReferenceNode = null;
     neighborPubkeys = null;
     delete window._mapSelectRefNode;
+    delete window._mapGetNeighborPubkeys;
   }
 
   function toggleHeatmap(on) {
@@ -875,6 +999,95 @@
 
   let _themeRefreshHandler = null;
 
+  // ─── Affinity Debug Overlay ────────────────────────────────────────────────
+  function clearAffinityOverlay() {
+    if (affinityLayer) { map.removeLayer(affinityLayer); affinityLayer = null; }
+    affinityData = null;
+  }
+
+  function loadAffinityDebugOverlay() {
+    clearAffinityOverlay();
+    // Fetch debug data — requires API key stored in localStorage
+    var apiKey = localStorage.getItem('meshcore-api-key') || '';
+    fetch('/api/debug/affinity', { headers: { 'X-API-Key': apiKey } })
+      .then(function (r) { if (!r.ok) throw new Error('HTTP ' + r.status); return r.json(); })
+      .then(function (data) {
+        affinityData = data;
+        renderAffinityOverlay();
+      })
+      .catch(function (err) {
+        console.warn('[affinity-debug] Failed to load:', err);
+        var cb = document.getElementById('mcAffinityDebug');
+        if (cb) cb.checked = false;
+      });
+  }
+
+  function renderAffinityOverlay() {
+    if (!affinityData || !map) return;
+    clearAffinityOverlay();
+    affinityLayer = L.layerGroup();
+
+    // Build node position lookup from current markers
+    var nodePos = {};
+    nodes.forEach(function (n) {
+      if (n.latitude && n.longitude) {
+        nodePos[n.public_key.toLowerCase()] = [n.latitude, n.longitude];
+      }
+    });
+
+    var edges = affinityData.edges || [];
+    edges.forEach(function (e) {
+      var posA = nodePos[e.nodeA];
+      var posB = e.nodeB ? nodePos[e.nodeB] : null;
+
+      if (!posA) return;
+
+      // Unresolved prefix — show ❓ marker near nodeA
+      if (e.unresolved || (!posB && e.ambiguous)) {
+        if (posA) {
+          var marker = L.marker([posA[0] + 0.001, posA[1] + 0.001], {
+            icon: L.divIcon({ html: '❓', className: 'affinity-unresolved', iconSize: [20, 20] })
+          });
+          marker.bindPopup('<b>Unresolved prefix:</b> ' + escapeHtml(e.prefix) + '<br>Observations: ' + e.weight);
+          affinityLayer.addLayer(marker);
+        }
+        return;
+      }
+
+      if (!posB) return;
+
+      // Color by confidence
+      var color = '#ef4444'; // red — ambiguous
+      var score = e.score || 0;
+      if (score >= 0.6) color = '#22c55e'; // green — high
+      else if (score >= 0.3) color = '#eab308'; // yellow — medium
+
+      // Thickness proportional to weight, clamped 1-5px
+      var weight = Math.max(1, Math.min(5, Math.round((e.weight || 1) / 20)));
+
+      var line = L.polyline([posA, posB], {
+        color: color,
+        weight: weight,
+        opacity: 0.7,
+        dashArray: e.ambiguous ? '5,5' : null
+      });
+
+      var popup = '<b>Affinity Edge</b><br>' +
+        escapeHtml(e.nodeAName || e.nodeA.substring(0, 8)) + ' ↔ ' + escapeHtml(e.nodeBName || e.nodeB.substring(0, 8)) + '<br>' +
+        'Observations: ' + e.observationCount + '<br>' +
+        'Score: ' + (e.score || 0).toFixed(3) + '<br>' +
+        'Last seen: ' + escapeHtml(e.lastSeen) + '<br>' +
+        'Observers: ' + escapeHtml((e.observers || []).join(', '));
+      if (e.avgSnr != null) popup += '<br>Avg SNR: ' + e.avgSnr.toFixed(1) + ' dB';
+
+      line.bindPopup(popup);
+      affinityLayer.addLayer(line);
+    });
+
+    affinityLayer.addTo(map);
+  }
+  // ─── End Affinity Debug ────────────────────────────────────────────────────
+
   registerPage('map', {
     init: function(app, routeParam) {
       _themeRefreshHandler = () => { if (markerLayer) renderMarkers(); };

public/node-analytics.js

@@ -51,7 +51,7 @@
     const nodeName = escapeHtml(n.name || n.public_key.slice(0, 12));
 
     container.innerHTML = `
-      <div style="max-width:1000px;margin:0 auto;padding:12px 16px;height:100%;overflow-y:auto">
+      <div style="max-width:1000px;margin:0 auto;padding:12px 16px">
         <div style="margin-bottom:12px">
           <a href="#/nodes/${encodeURIComponent(n.public_key)}" style="color:var(--accent);text-decoration:none;font-size:12px">← Back to ${nodeName}</a>
           <h2 style="margin:4px 0 2px;font-size:18px">📊 ${nodeName} — Analytics</h2>

public/nodes.js

@@ -20,26 +20,24 @@
   let activeTab = 'all';
   let search = '';
   // Sort state: column + direction, persisted to localStorage
-  let sortState = (function () {
-    try {
-      const saved = JSON.parse(localStorage.getItem('meshcore-nodes-sort'));
-      if (saved && saved.column && saved.direction) return saved;
-    } catch {}
-    return { column: 'last_seen', direction: 'desc' };
-  })();
+  // Managed by TableSort utility (public/table-sort.js) when DOM is available,
+  // falls back to simple object for unit testing
+  var _nodesTableSortCtrl = null;
+  // TODO(M5): remove fallback when tests use DOM sandbox
+  var _fallbackSortState = null; // used when TableSort controller not initialized (tests)
 
-  function toggleSort(column) {
-    if (sortState.column === column) {
-      sortState.direction = sortState.direction === 'asc' ? 'desc' : 'asc';
-    } else {
-      // Default direction per column type
-      const descDefault = ['last_seen', 'advert_count'];
-      sortState = { column, direction: descDefault.includes(column) ? 'desc' : 'asc' };
-    }
-    localStorage.setItem('meshcore-nodes-sort', JSON.stringify(sortState));
+  function _getSortState() {
+    if (_nodesTableSortCtrl) return _nodesTableSortCtrl.getState();
+    if (_fallbackSortState) return _fallbackSortState;
+    try {
+      var saved = JSON.parse(localStorage.getItem('meshcore-nodes-sort'));
+      if (saved && saved.column && saved.direction) return saved;
+    } catch (e) { /* ignore */ }
+    return { column: 'last_seen', direction: 'desc' };
   }
 
   function sortNodes(arr) {
+    var sortState = _getSortState();
     const col = sortState.column;
     const dir = sortState.direction === 'asc' ? 1 : -1;
     return arr.sort(function (a, b) {
@@ -66,11 +64,6 @@
       return 0;
     });
   }
-
-  function sortArrow(col) {
-    if (sortState.column !== col) return '';
-    return '<span class="sort-arrow">' + (sortState.direction === 'asc' ? '▲' : '▼') + '</span>';
-  }
   let lastHeard = localStorage.getItem('meshcore-nodes-last-heard') || '';
   let statusFilter = localStorage.getItem('meshcore-nodes-status-filter') || 'all';
   let wsHandler = null;
@@ -85,6 +78,18 @@
     { key: 'sensor', label: 'Sensors' },
   ];
 
+  function buildNodesQuery(tab, searchStr) {
+    var parts = [];
+    if (tab && tab !== 'all') parts.push('tab=' + encodeURIComponent(tab));
+    if (searchStr) parts.push('search=' + encodeURIComponent(searchStr));
+    return parts.length ? '?' + parts.join('&') : '';
+  }
+  window.buildNodesQuery = buildNodesQuery;
+
+  function updateNodesUrl() {
+    history.replaceState(null, '', '#/nodes' + buildNodesQuery(activeTab, search));
+  }
+
   function renderNodeTimestampHtml(isoString) {
     if (typeof formatTimestampWithTooltip !== 'function' || typeof getTimestampMode !== 'function') {
       return escapeHtml(typeof timeAgo === 'function' ? timeAgo(isoString) : '—');
@@ -175,6 +180,137 @@
     return `<div style="font-size:11px;color:var(--text-muted);margin:-2px 0 6px;padding:6px 10px;background:var(--surface-2);border-radius:4px;border-left:3px solid var(--status-yellow)">Adverts show varying hash sizes (<strong>${sizes.join('-byte, ')}-byte</strong>). This is a <a href="https://github.com/meshcore-dev/MeshCore/commit/fcfdc5f" target="_blank" style="color:var(--accent)">known bug</a> where automatic adverts ignore the configured multibyte path setting. Fixed in <a href="https://github.com/meshcore-dev/MeshCore/releases/tag/repeater-v1.14.1" target="_blank" style="color:var(--accent)">repeater v1.14.1</a>.</div>`;
   }
 
+  // ─── Neighbor section helpers ───────────────────────────────────────────────
+
+  // Cache: pubkey → { data, ts }
+  var _neighborCache = {};
+
+  function getConfidenceIndicator(entry) {
+    if (entry.ambiguous) return { icon: '⚠️', label: 'AMBIGUOUS', cls: 'confidence-ambiguous' };
+    if (entry.count <= 1) return { icon: '🔴', label: 'LOW', cls: 'confidence-low' };
+    if (entry.score >= 0.5 && entry.count >= 3) return { icon: '🟢', label: 'HIGH', cls: 'confidence-high' };
+    return { icon: '🟡', label: 'MEDIUM', cls: 'confidence-medium' };
+  }
+
+  function renderNeighborRows(neighbors, limit) {
+    var sorted = neighbors.slice().sort(function(a, b) {
+      return (b.count || 0) - (a.count || 0);
+    });
+    var items = limit ? sorted.slice(0, limit) : sorted;
+    return items.map(function(nb) {
+      var conf = getConfidenceIndicator(nb);
+      var name = nb.name || (nb.prefix + '… (unknown)');
+      var nameHtml = nb.pubkey
+        ? '<a href="#/nodes/' + encodeURIComponent(nb.pubkey) + '">' + escapeHtml(name) + '</a>'
+        : '<span class="text-muted">' + escapeHtml(name) + '</span>';
+      var role = nb.role || '—';
+      var roleBadge = nb.role
+        ? '<span class="badge" style="background:' + (ROLE_COLORS[nb.role] || 'var(--surface-2)') + ';color:#fff;font-size:10px">' + escapeHtml(role) + '</span>'
+        : '<span class="text-muted">—</span>';
+      var scoreTitle = 'Observations: ' + nb.count;
+      if (nb.avg_snr != null) scoreTitle += ' · Avg SNR: ' + Number(nb.avg_snr).toFixed(1) + ' dB';
+      var distanceCell = nb.distance_km != null
+        ? formatDistance(Number(nb.distance_km))
+        : '<span class="text-muted">—</span>';
+      var showOnMap = nb.pubkey
+        ? ' <button class="btn-link neighbor-show-map" data-pubkey="' + escapeHtml(nb.pubkey) + '" style="font-size:11px;padding:1px 6px;white-space:nowrap">📍 Map</button>'
+        : '';
+      var lastSeenVal = nb.last_seen ? new Date(nb.last_seen).getTime() : 0;
+      var distanceVal = nb.distance_km != null ? Number(nb.distance_km) : '';
+      return '<tr>' +
+        '<td data-value="' + escapeHtml(name.toLowerCase()) + '" style="font-weight:600">' + nameHtml + '</td>' +
+        '<td data-value="' + escapeHtml(role.toLowerCase()) + '">' + roleBadge + '</td>' +
+        '<td data-value="' + Number(nb.score || 0) + '" title="' + escapeHtml(scoreTitle) + '">' + Number(nb.score).toFixed(2) + '</td>' +
+        '<td data-value="' + (nb.count || 0) + '">' + nb.count + '</td>' +
+        '<td data-value="' + lastSeenVal + '">' + renderNodeTimestampHtml(nb.last_seen) + '</td>' +
+        '<td data-value="' + distanceVal + '">' + distanceCell + '</td>' +
+        '<td><span title="' + conf.label + '">' + conf.icon + '</span></td>' +
+        '<td style="text-align:right">' + showOnMap + '</td>' +
+        '</tr>';
+    }).join('');
+  }
+
+  function renderNeighborTable(neighbors, limit) {
+    return '<table class="data-table neighbor-sort-table" style="font-size:12px">' +
+      '<thead><tr>' +
+      '<th scope="col" data-sort-key="name">Neighbor</th>' +
+      '<th scope="col" data-sort-key="role">Role</th>' +
+      '<th scope="col" data-sort-key="score" data-type="numeric" data-sort-default="desc">Score</th>' +
+      '<th scope="col" data-sort-key="count" data-type="numeric" data-sort-default="desc">Obs</th>' +
+      '<th scope="col" data-sort-key="last_seen" data-type="numeric" data-sort-default="desc">Last Seen</th>' +
+      '<th scope="col" data-sort-key="distance" data-type="numeric">Distance</th>' +
+      '<th scope="col">Conf</th><th scope="col"></th>' +
+      '</tr></thead>' +
+      '<tbody>' + renderNeighborRows(neighbors, limit) + '</tbody></table>';
+  }
+
+  function fetchAndRenderNeighbors(pubkey, containerId, opts) {
+    opts = opts || {};
+    var limit = opts.limit || 0;
+    var headerSelector = opts.headerSelector;
+    var viewAllPubkey = opts.viewAllPubkey;
+
+    // Always set spinner as initial DOM state (synchronous) so tests can observe it
+    var spinnerEl = document.getElementById(containerId);
+    if (spinnerEl) spinnerEl.innerHTML = '<div class="text-muted" style="padding:8px"><span class="spinner"></span> Loading neighbors…</div>';
+
+    // Check cache
+    var cached = _neighborCache[pubkey];
+    if (cached && (Date.now() - cached.ts < 300000)) { // 5 min cache
+      renderNeighborData(cached.data, containerId, limit, headerSelector, viewAllPubkey);
+      return;
+    }
+
+    api('/nodes/' + encodeURIComponent(pubkey) + '/neighbors', { ttl: CLIENT_TTL.nodeDetail }).then(function(data) {
+      _neighborCache[pubkey] = { data: data, ts: Date.now() };
+      renderNeighborData(data, containerId, limit, headerSelector, viewAllPubkey);
+    }).catch(function() {
+      var el = document.getElementById(containerId);
+      if (el) el.innerHTML = '<div class="text-muted" style="padding:8px">Could not load neighbor data</div>';
+    });
+  }
+
+  function renderNeighborData(data, containerId, limit, headerSelector, viewAllPubkey) {
+    var el = document.getElementById(containerId);
+    if (!el) return;
+    if (!data || !data.neighbors || !data.neighbors.length) {
+      el.innerHTML = '<div class="text-muted" style="padding:8px">No neighbor data available yet. Neighbor relationships are built from observed packet paths over time.</div>';
+      if (headerSelector) {
+        var h = document.querySelector(headerSelector);
+        if (h) h.textContent = 'Neighbors (0)';
+      }
+      return;
+    }
+    if (headerSelector) {
+      var h = document.querySelector(headerSelector);
+      if (h) h.textContent = 'Neighbors (' + data.neighbors.length + ')';
+    }
+    var html = renderNeighborTable(data.neighbors, limit);
+    if (limit && data.neighbors.length > limit && viewAllPubkey) {
+      html += '<div style="margin-top:6px;text-align:right"><a href="#/nodes/' + encodeURIComponent(viewAllPubkey) + '?section=node-neighbors" style="font-size:12px">View all ' + data.neighbors.length + ' neighbors →</a></div>';
+    }
+    el.innerHTML = html;
+
+    // Initialize TableSort on neighbor table
+    var neighborTable = el.querySelector('.neighbor-sort-table');
+    if (neighborTable && window.TableSort) {
+      TableSort.init(neighborTable, {
+        defaultColumn: 'count',
+        defaultDirection: 'desc'
+      });
+    }
+
+    // Wire up "Show on Map" buttons via event delegation
+    el.addEventListener('click', function(e) {
+      var btn = e.target.closest('.neighbor-show-map');
+      if (!btn) return;
+      var pk = btn.getAttribute('data-pubkey');
+      if (pk) location.hash = '#/map?node=' + encodeURIComponent(pk);
+    });
+  }
+
+  // ─── End neighbor helpers ─────────────────────────────────────────────────
+
   let directNode = null; // set when navigating directly to #/nodes/:pubkey
 
   let regionChangeHandler = null;
@@ -205,6 +341,15 @@
       return;
     }
 
+    // Reset list-view state to defaults, then override from URL params
+    activeTab = 'all';
+    search = '';
+    const _listUrlParams = getHashParams();
+    const _urlTab = _listUrlParams.get('tab');
+    const _urlSearch = _listUrlParams.get('search');
+    if (_urlTab && TABS.some(function(t) { return t.key === _urlTab; })) activeTab = _urlTab;
+    if (_urlSearch) search = _urlSearch;
+
     app.innerHTML = `<div class="nodes-page">
       <div class="nodes-topbar">
         <input type="text" class="nodes-search" id="nodeSearch" placeholder="Search nodes by name…" aria-label="Search nodes by name">
@@ -212,7 +357,7 @@
       </div>
       <div id="nodesRegionFilter" class="region-filter-container"></div>
       <div class="split-layout">
-        <div class="panel-left" id="nodesLeft"></div>
+        <div class="panel-left" id="nodesLeft" aria-live="polite" aria-relevant="additions removals"></div>
         <div class="panel-right empty" id="nodesRight"><span>Select a node to view details</span></div>
       </div>
     </div>`;
@@ -220,8 +365,14 @@
     RegionFilter.init(document.getElementById('nodesRegionFilter'));
     regionChangeHandler = RegionFilter.onChange(function () { _allNodes = null; loadNodes(); });
 
+    if (search) {
+      var _si = document.getElementById('nodeSearch');
+      if (_si) _si.value = search;
+    }
+
     document.getElementById('nodeSearch').addEventListener('input', debounce(e => {
       search = e.target.value;
+      updateNodesUrl();
       loadNodes();
     }, 250));
 
@@ -264,13 +415,25 @@
     }, 5000);
   }
 
+  /**
+   * Fetch node detail + health data in parallel.
+   * Both selectNode() and loadFullNode() need the same data —
+   * this shared helper avoids duplicating the fetch logic (fixes #391).
+   */
+  async function fetchNodeDetail(pubkey) {
+    const [nodeData, healthData] = await Promise.all([
+      api('/nodes/' + encodeURIComponent(pubkey), { ttl: CLIENT_TTL.nodeDetail }),
+      api('/nodes/' + encodeURIComponent(pubkey) + '/health', { ttl: CLIENT_TTL.nodeDetail }).catch(() => null)
+    ]);
+    nodeData.healthData = healthData;
+    return nodeData;
+  }
+
   async function loadFullNode(pubkey) {
     const body = document.getElementById('nodeFullBody');
     try {
-      const [nodeData, healthData] = await Promise.all([
-        api('/nodes/' + encodeURIComponent(pubkey), { ttl: CLIENT_TTL.nodeDetail }),
-        api('/nodes/' + encodeURIComponent(pubkey) + '/health', { ttl: CLIENT_TTL.nodeDetail }).catch(() => null)
-      ]);
+      const nodeData = await fetchNodeDetail(pubkey);
+      const healthData = nodeData.healthData;
       const n = nodeData.node;
       const adverts = (nodeData.recentAdverts || []).sort((a, b) => new Date(b.timestamp) - new Date(a.timestamp));
       const title = document.querySelector('.node-full-title');
@@ -333,20 +496,38 @@
         ${observers.length ? `<div class="node-full-card" id="node-observers">
           ${(() => { const regions = [...new Set(observers.map(o => o.iata).filter(Boolean))]; return regions.length ? `<div style="margin-bottom:8px"><strong>Regions:</strong> ${regions.map(r => '<span class="badge" style="margin:0 2px">' + escapeHtml(r) + '</span>').join(' ')}</div>` : ''; })()}
           <h4>Heard By (${observers.length} observer${observers.length > 1 ? 's' : ''})</h4>
-          <table class="data-table" style="font-size:12px">
-            <thead><tr><th scope="col">Observer</th><th scope="col">Region</th><th scope="col">Packets</th><th scope="col">Avg SNR</th><th scope="col">Avg RSSI</th></tr></thead>
+          <table class="data-table observer-sort-table" style="font-size:12px">
+            <thead><tr>
+              <th scope="col" data-sort-key="observer">Observer</th>
+              <th scope="col" data-sort-key="region">Region</th>
+              <th scope="col" data-sort-key="packets" data-type="numeric" data-sort-default="desc">Packets</th>
+              <th scope="col" data-sort-key="snr" data-type="numeric" data-sort-default="desc">Avg SNR</th>
+              <th scope="col" data-sort-key="rssi" data-type="numeric" data-sort-default="desc">Avg RSSI</th>
+            </tr></thead>
             <tbody>
               ${observers.map(o => `<tr>
-                <td style="font-weight:600">${escapeHtml(o.observer_name || o.observer_id)}</td>
-                <td>${o.iata ? escapeHtml(o.iata) : '—'}</td>
-                <td>${o.packetCount}</td>
-                <td>${o.avgSnr != null ? Number(o.avgSnr).toFixed(1) + ' dB' : '—'}</td>
-                <td>${o.avgRssi != null ? Number(o.avgRssi).toFixed(0) + ' dBm' : '—'}</td>
+                <td data-value="${escapeHtml((o.observer_name || o.observer_id || '').toLowerCase())}" style="font-weight:600">${escapeHtml(o.observer_name || o.observer_id)}</td>
+                <td data-value="${escapeHtml((o.iata || '').toLowerCase())}">${o.iata ? escapeHtml(o.iata) : '—'}</td>
+                <td data-value="${o.packetCount || 0}">${o.packetCount}</td>
+                <td data-value="${o.avgSnr != null ? Number(o.avgSnr) : ''}">${o.avgSnr != null ? Number(o.avgSnr).toFixed(1) + ' dB' : '—'}</td>
+                <td data-value="${o.avgRssi != null ? Number(o.avgRssi) : ''}">${o.avgRssi != null ? Number(o.avgRssi).toFixed(0) + ' dBm' : '—'}</td>
               </tr>`).join('')}
             </tbody>
           </table>
         </div>` : ''}
 
+        <div class="node-full-card" id="node-neighbors">
+          <h4 id="fullNeighborsHeader">Neighbors</h4>
+          <div id="fullNeighborsContent"><div class="text-muted" style="padding:8px"><span class="spinner"></span> Loading neighbors…</div></div>
+        </div>
+
+        <div class="node-full-card" id="node-affinity-debug" style="display:none">
+          <h4 style="cursor:pointer" onclick="this.parentElement.querySelector('.affinity-debug-body').style.display=this.parentElement.querySelector('.affinity-debug-body').style.display==='none'?'block':'none'; this.querySelector('.toggle-icon').textContent=this.parentElement.querySelector('.affinity-debug-body').style.display==='none'?'▶':'▼'"><span class="toggle-icon">▶</span> 🔍 Affinity Debug</h4>
+          <div class="affinity-debug-body" style="display:none">
+            <div id="affinityDebugContent"><div class="text-muted" style="padding:8px"><span class="spinner"></span> Loading debug data…</div></div>
+          </div>
+        </div>
+
         <div class="node-full-card" id="fullPathsSection">
           <h4>Paths Through This Node</h4>
           <div id="fullPathsContent"><div class="text-muted" style="padding:8px"><span class="spinner"></span> Loading paths…</div></div>
@@ -367,10 +548,12 @@
               let hashSizeBadge = '';
               if (n.hash_size_inconsistent && p.payload_type === 4 && p.raw_hex) {
                 const pb = parseInt(p.raw_hex.slice(2, 4), 16);
-                const hs = ((pb >> 6) & 0x3) + 1;
-                const hsColor = hs >= 3 ? '#16a34a' : hs === 2 ? '#86efac' : '#f97316';
-                const hsFg = hs === 2 ? '#064e3b' : '#fff';
-                hashSizeBadge = ` <span class="badge" style="background:${hsColor};color:${hsFg};font-size:9px;font-family:var(--mono)">${hs}B</span>`;
+                if ((pb & 0x3F) !== 0) {
+                  const hs = ((pb >> 6) & 0x3) + 1;
+                  const hsColor = hs >= 3 ? '#16a34a' : hs === 2 ? '#86efac' : '#f97316';
+                  const hsFg = hs === 2 ? '#064e3b' : '#fff';
+                  hashSizeBadge = ` <span class="badge" style="background:${hsColor};color:${hsFg};font-size:9px;font-family:var(--mono)">${hs}B</span>`;
+                }
               }
               return `<div class="node-activity-item">
                 <span class="node-activity-time">${renderNodeTimestampHtml(p.timestamp)}</span>
@@ -427,6 +610,112 @@
         } catch {}
       }
 
+      // Initialize TableSort on observer table (full detail page)
+      var observerTable = document.querySelector('#node-observers .observer-sort-table');
+      if (observerTable && window.TableSort) {
+        TableSort.init(observerTable, {
+          defaultColumn: 'packets',
+          defaultDirection: 'desc'
+        });
+      }
+
+      // Fetch neighbors for this node (full-screen view)
+      fetchAndRenderNeighbors(n.public_key, 'fullNeighborsContent', {
+        headerSelector: '#fullNeighborsHeader'
+      });
+
+      // Affinity debug panel — show if debugAffinity is enabled
+      (function loadAffinityDebug() {
+        var show = (window.CLIENT_CONFIG && window.CLIENT_CONFIG.debugAffinity) || localStorage.getItem('meshcore-affinity-debug') === 'true';
+        var panel = document.getElementById('node-affinity-debug');
+        if (!show || !panel) return;
+        panel.style.display = '';
+        var apiKey = localStorage.getItem('meshcore-api-key') || '';
+        fetch('/api/debug/affinity?node=' + encodeURIComponent(n.public_key), { headers: { 'X-API-Key': apiKey } })
+          .then(function (r) { if (!r.ok) throw new Error('HTTP ' + r.status); return r.json(); })
+          .then(function (data) {
+            var el = document.getElementById('affinityDebugContent');
+            if (!el) return;
+            var html = '';
+
+            // Edges table
+            if (data.edges && data.edges.length) {
+              html += '<h5 style="margin:8px 0 4px">Neighbor Edges (' + data.edges.length + ')</h5>';
+              html += '<table class="mini-table" style="width:100%;font-size:12px"><thead><tr><th>Neighbor</th><th>Score</th><th>Count</th><th>Last Seen</th><th>Observers</th><th>Status</th></tr></thead><tbody>';
+              data.edges.forEach(function (e) {
+                var neighbor = e.nodeBName || e.nodeAName || (e.nodeB || e.nodeA || '').substring(0, 8);
+                if (e.nodeA.toLowerCase() === n.public_key.toLowerCase()) {
+                  neighbor = e.nodeBName || (e.nodeB || e.prefix || '?').substring(0, 8);
+                } else {
+                  neighbor = e.nodeAName || (e.nodeA || '').substring(0, 8);
+                }
+                var status = e.ambiguous ? (e.unresolved ? '❓ Unresolved' : '⚠️ Ambiguous') : (e.resolved ? '✅ Auto-resolved' : '✅ Resolved');
+                html += '<tr><td>' + escapeHtml(neighbor) + '</td><td>' + (e.score || 0).toFixed(3) + '</td><td>' + e.weight + '</td><td>' + (e.lastSeen || '').substring(0, 10) + '</td><td>' + (e.observers || []).length + '</td><td>' + status + '</td></tr>';
+              });
+              html += '</tbody></table>';
+            } else {
+              html += '<div class="text-muted" style="padding:8px">No affinity edges for this node</div>';
+            }
+
+            // Resolutions
+            if (data.resolutions && data.resolutions.length) {
+              html += '<h5 style="margin:12px 0 4px">Prefix Resolutions (' + data.resolutions.length + ')</h5>';
+              data.resolutions.forEach(function (r) {
+                html += '<div style="border:1px solid var(--border);border-radius:4px;padding:8px;margin-bottom:6px;font-size:12px">';
+                html += '<b>Prefix: ' + escapeHtml(r.prefix) + '</b> → ';
+                if (r.method === 'auto-resolved') {
+                  html += '<span style="color:var(--status-green)">✅ ' + escapeHtml(r.chosenName || r.chosen || '?') + '</span>';
+                  html += ' (Jaccard=' + r.chosenJaccard.toFixed(2) + ', ratio=' + ((isFinite(r.ratio) && r.ratio < 100) ? r.ratio.toFixed(1) + '×' : '∞') + ')';
+                } else {
+                  html += '<span style="color:var(--status-yellow)">⚠️ Ambiguous</span>';
+                  if (r.ratio) html += ' (ratio=' + r.ratio.toFixed(1) + '×, threshold=' + r.thresholdApplied + '×)';
+                }
+                // Show disambiguation tier used (M4 resolveWithContext)
+                if (r.tier) {
+                  var tierLabels = {
+                    'neighbor_affinity': '🏘️ Affinity',
+                    'geo_proximity': '🌍 Geo',
+                    'gps_preference': '📍 GPS',
+                    'first_match': '🎲 Naive',
+                    'unique_prefix': '✓ Unique',
+                    'no_match': '∅ None'
+                  };
+                  html += ' <span style="font-size:11px;opacity:0.8">[tier: ' + (tierLabels[r.tier] || escapeHtml(r.tier)) + ']</span>';
+                }
+                // Candidates table
+                if (r.candidates && r.candidates.length) {
+                  html += '<div style="margin-top:4px"><table class="mini-table" style="width:100%;font-size:11px"><thead><tr><th>Candidate</th><th>Jaccard</th><th>Count</th></tr></thead><tbody>';
+                  r.candidates.forEach(function (c) {
+                    var highlight = r.chosen && c.pubkey === r.chosen ? ' style="background:var(--status-green-bg,rgba(34,197,94,0.1))"' : '';
+                    html += '<tr' + highlight + '><td>' + escapeHtml(c.name || c.pubkey.substring(0, 8)) + '</td><td>' + c.jaccard.toFixed(3) + '</td><td>' + c.score + '</td></tr>';
+                  });
+                  html += '</tbody></table></div>';
+                }
+                html += '</div>';
+              });
+            }
+
+            // Stats summary
+            if (data.stats) {
+              html += '<h5 style="margin:12px 0 4px">Graph Stats</h5>';
+              html += '<div style="font-size:12px;line-height:1.6">';
+              html += 'Total edges: ' + data.stats.totalEdges + '<br>';
+              html += 'Total nodes: ' + data.stats.totalNodes + '<br>';
+              html += 'Resolved: ' + data.stats.resolvedCount + ' | Ambiguous: ' + data.stats.ambiguousCount + ' | Unresolved: ' + data.stats.unresolvedCount + '<br>';
+              html += 'Avg confidence: ' + (data.stats.avgConfidence || 0).toFixed(3) + '<br>';
+              html += 'Cold-start coverage: ' + (data.stats.coldStartCoverage || 0).toFixed(1) + '%<br>';
+              html += 'Cache age: ' + (data.stats.cacheAge || 'N/A') + ' | Last rebuild: ' + (data.stats.lastRebuild || 'N/A');
+              html += '</div>';
+            }
+
+            el.innerHTML = html;
+          })
+          .catch(function (err) {
+            var el = document.getElementById('affinityDebugContent');
+            if (el) el.innerHTML = '<div class="text-muted" style="padding:8px">Failed to load debug data: ' + escapeHtml(err.message) + '</div>';
+          });
+      })();
+
       // Fetch paths through this node (full-screen view)
       api('/nodes/' + encodeURIComponent(n.public_key) + '/paths', { ttl: CLIENT_TTL.nodeDetail }).then(pathData => {
         const el = document.getElementById('fullPathsContent');
@@ -626,11 +915,11 @@
       </div>
       <table class="data-table" id="nodesTable">
         <thead><tr>
-          <th scope="col" class="sortable${sortState.column==='name'?' sort-active':''}" data-sort="name">Name${sortArrow('name')}</th>
-          <th scope="col" class="col-pubkey sortable${sortState.column==='public_key'?' sort-active':''}" data-sort="public_key">Public Key${sortArrow('public_key')}</th>
-          <th scope="col" class="sortable${sortState.column==='role'?' sort-active':''}" data-sort="role">Role${sortArrow('role')}</th>
-          <th scope="col" class="sortable${sortState.column==='last_seen'?' sort-active':''}" data-sort="last_seen">Last Seen${sortArrow('last_seen')}</th>
-          <th scope="col" class="sortable${sortState.column==='advert_count'?' sort-active':''}" data-sort="advert_count">Adverts${sortArrow('advert_count')}</th>
+          <th scope="col" data-sort-key="name">Name</th>
+          <th scope="col" class="col-pubkey" data-sort-key="public_key">Public Key</th>
+          <th scope="col" data-sort-key="role">Role</th>
+          <th scope="col" data-sort-key="last_seen" data-sort-default="desc">Last Seen</th>
+          <th scope="col" data-sort-key="advert_count" data-sort-default="desc">Adverts</th>
         </tr></thead>
         <tbody id="nodesBody"></tbody>
       </table>`;
@@ -639,7 +928,7 @@
     const nodeTabs = document.getElementById('nodeTabs');
     initTabBar(nodeTabs);
     el.querySelectorAll('.node-tab').forEach(btn => {
-      btn.addEventListener('click', () => { activeTab = btn.dataset.tab; loadNodes(); });
+      btn.addEventListener('click', () => { activeTab = btn.dataset.tab; updateNodesUrl(); loadNodes(); });
     });
 
     // Filter changes
@@ -655,10 +944,18 @@
       });
     });
 
-    // Sortable column headers
-    el.querySelectorAll('th.sortable').forEach(th => {
-      th.addEventListener('click', () => { toggleSort(th.dataset.sort); renderLeft(); });
-    });
+    // Initialize TableSort on nodes table (handles header clicks, indicators, persistence)
+    // We use onSort callback to re-render rows (sorting is done at JS-array level in renderRows
+    // because of claimed/favorites pinning logic that TableSort can't handle)
+    var nodesTableEl = document.getElementById('nodesTable');
+    if (nodesTableEl && window.TableSort) {
+      _nodesTableSortCtrl = TableSort.init(nodesTableEl, {
+        defaultColumn: 'last_seen',
+        defaultDirection: 'desc',
+        storageKey: 'meshcore-nodes-sort',
+        onSort: function () { renderRows(); }
+      });
+    }
 
     // Delegated click/keyboard handler for table rows
     const tbody = document.getElementById('nodesBody');
@@ -687,6 +984,17 @@
       }
     });
 
+    // #630: Close button for node detail panel (important for mobile full-screen overlay)
+    document.getElementById('nodesRight').addEventListener('click', function(e) {
+      if (e.target.closest('.panel-close-btn')) {
+        const panel = document.getElementById('nodesRight');
+        panel.classList.add('empty');
+        panel.innerHTML = '<span>Select a node to view details</span>';
+        selectedKey = null;
+        renderRows();
+      }
+    });
+
     renderRows();
   }
 
@@ -746,11 +1054,7 @@
     panel.innerHTML = '<div class="text-center text-muted" style="padding:40px">Loading…</div>';
 
     try {
-      const [data, healthData] = await Promise.all([
-        api('/nodes/' + encodeURIComponent(pubkey), { ttl: CLIENT_TTL.nodeDetail }),
-        api('/nodes/' + encodeURIComponent(pubkey) + '/health', { ttl: CLIENT_TTL.nodeDetail }).catch(() => null)
-      ]);
-      data.healthData = healthData;
+      const data = await fetchNodeDetail(pubkey);
       renderDetail(panel, data);
     } catch (e) {
       panel.innerHTML = `<div class="text-muted">Error: ${e.message}</div>`;
@@ -778,6 +1082,7 @@
     const dupBadge = dupNameBadge(n.name, n.public_key, dupMap);
 
     panel.innerHTML = `
+      <button class="panel-close-btn" title="Close detail pane (Esc)">✕</button>
       <div class="node-detail">
         <div class="node-detail-name">${escapeHtml(n.name || '(unnamed)')}${dupBadge}</div>
         <div class="node-detail-role">${renderNodeBadges(n, roleColor)}
@@ -819,6 +1124,11 @@
           </div>
         </div>` : ''}
 
+        <div class="node-detail-section" id="panelNeighborsSection">
+          <h4 id="panelNeighborsHeader">Neighbors</h4>
+          <div id="panelNeighborsContent"><div class="text-muted" style="padding:8px"><span class="spinner"></span> Loading neighbors…</div></div>
+        </div>
+
         <div class="node-detail-section" id="pathsSection">
           <h4>Paths Through This Node</h4>
           <div id="pathsContent"><div class="text-muted" style="padding:8px"><span class="spinner"></span> Loading paths…</div></div>
@@ -889,6 +1199,13 @@
       } catch {}
     }
 
+    // Fetch neighbors for this node (condensed panel — top 5)
+    fetchAndRenderNeighbors(n.public_key, 'panelNeighborsContent', {
+      limit: 5,
+      headerSelector: '#panelNeighborsHeader',
+      viewAllPubkey: n.public_key
+    });
+
     // Fetch paths through this node
     api('/nodes/' + encodeURIComponent(n.public_key) + '/paths', { ttl: CLIENT_TTL.nodeDetail }).then(pathData => {
       const el = document.getElementById('pathsContent');
@@ -959,11 +1276,29 @@
   window._nodesIsAdvertMessage = isAdvertMessage;
   window._nodesGetAllNodes = function() { return _allNodes; };
   window._nodesSetAllNodes = function(n) { _allNodes = n; };
-  window._nodesToggleSort = toggleSort;
+  window._nodesToggleSort = function(col) {
+    if (_nodesTableSortCtrl) { _nodesTableSortCtrl.sort(col); return; }
+    // Fallback for tests without DOM
+    var st = _getSortState();
+    var descDefault = ['last_seen', 'advert_count'];
+    if (st.column === col) {
+      _fallbackSortState = { column: col, direction: st.direction === 'asc' ? 'desc' : 'asc' };
+    } else {
+      _fallbackSortState = { column: col, direction: descDefault.indexOf(col) >= 0 ? 'desc' : 'asc' };
+    }
+    localStorage.setItem('meshcore-nodes-sort', JSON.stringify(_fallbackSortState));
+  };
   window._nodesSortNodes = sortNodes;
-  window._nodesSortArrow = sortArrow;
-  window._nodesGetSortState = function() { return sortState; };
-  window._nodesSetSortState = function(s) { sortState = s; };
+  window._nodesSortArrow = function(col) {
+    var st = _getSortState();
+    if (st.column !== col) return '';
+    return '<span class="sort-arrow">' + (st.direction === 'asc' ? '▲' : '▼') + '</span>';
+  };
+  window._nodesGetSortState = _getSortState;
+  window._nodesSetSortState = function(s) {
+    _fallbackSortState = s;
+    if (_nodesTableSortCtrl) _nodesTableSortCtrl.sort(s.column, s.direction);
+  };
   window._nodesSyncClaimedToFavorites = syncClaimedToFavorites;
   window._nodesRenderNodeTimestampHtml = renderNodeTimestampHtml;
   window._nodesRenderNodeTimestampText = renderNodeTimestampText;

public/observer-detail.js

@@ -37,7 +37,7 @@
     }
 
     app.innerHTML = `
-      <div class="observer-detail-page" style="overflow-y:auto;height:calc(100vh - 56px);padding:16px">
+      <div class="observer-detail-page" style="padding:16px">
         <div class="page-header" style="display:flex;align-items:center;gap:12px;margin-bottom:16px">
           <a href="#/observers" class="btn-icon" title="Back to Observers" aria-label="Back">←</a>
           <h2 style="margin:0" id="obsTitle">Observer Detail</h2>

public/packet-helpers.js

@@ -0,0 +1,61 @@
+/* === CoreScope — packet-helpers.js (shared packet utilities) === */
+'use strict';
+
+/**
+ * Cached JSON.parse helpers for packet data (issue #387).
+ * Avoids repeated parsing of path_json / decoded_json on the same packet object.
+ * Results are cached as _parsedPath / _parsedDecoded properties on the packet.
+ *
+ * Handles pre-parsed objects (non-string values) gracefully — returns them as-is.
+ */
+
+window.getParsedPath = function getParsedPath(p) {
+  if (p._parsedPath !== undefined) return p._parsedPath || [];
+  var raw = p.path_json;
+  if (typeof raw !== 'string') {
+    p._parsedPath = Array.isArray(raw) ? raw : [];
+    return p._parsedPath;
+  }
+  try { p._parsedPath = JSON.parse(raw) || []; } catch (e) { p._parsedPath = []; }
+  return p._parsedPath;
+};
+
+/**
+ * Clear cached _parsedPath/_parsedDecoded from a packet object.
+ * Must be called after spreading a parent packet into an observation/child,
+ * otherwise the child inherits stale cached values from the parent (issue #504).
+ */
+window.clearParsedCache = function clearParsedCache(p) {
+  delete p._parsedPath;
+  delete p._parsedDecoded;
+  delete p._parsedResolvedPath;
+  return p;
+};
+
+/**
+ * Parse resolved_path (server-side resolved full pubkeys).
+ * Returns array of pubkey strings (or null entries) if present, or null if absent.
+ * Cached as _parsedResolvedPath on the packet object.
+ */
+window.getResolvedPath = function getResolvedPath(p) {
+  if (p._parsedResolvedPath !== undefined) return p._parsedResolvedPath;
+  var raw = p.resolved_path;
+  if (!raw) { p._parsedResolvedPath = null; return null; }
+  if (typeof raw !== 'string') {
+    p._parsedResolvedPath = Array.isArray(raw) ? raw : null;
+    return p._parsedResolvedPath;
+  }
+  try { p._parsedResolvedPath = JSON.parse(raw) || null; } catch (e) { p._parsedResolvedPath = null; }
+  return p._parsedResolvedPath;
+};
+
+window.getParsedDecoded = function getParsedDecoded(p) {
+  if (p._parsedDecoded !== undefined) return p._parsedDecoded || {};
+  var raw = p.decoded_json;
+  if (typeof raw !== 'string') {
+    p._parsedDecoded = (raw && typeof raw === 'object') ? raw : {};
+    return p._parsedDecoded;
+  }
+  try { p._parsedDecoded = JSON.parse(raw) || {}; } catch (e) { p._parsedDecoded = {}; }
+  return p._parsedDecoded;
+};