fix(meshtastic): configure replay last_heard guards + WoA CI runner advance-test

.github/actionlint.yaml

@@ -0,0 +1,4 @@
+# GitHub-hosted labels not yet in actionlint's built-in list.
+self-hosted-runner:
+  labels:
+    - windows-11-vs2026-arm

.github/workflows/build.yaml

@@ -230,7 +230,7 @@ jobs:
             label: x64 NSIS install
             artifact: mesh-client-windows-${{ github.sha }}
             smoke_run: node scripts/test-win-nsis-install.mjs --arch x64
-          - os: windows-11-arm
+          - os: windows-11-vs2026-arm
             label: arm64 NSIS install (WoA)
             artifact: mesh-client-windows-${{ github.sha }}
             smoke_run: node scripts/test-win-nsis-install.mjs --arch arm64 --probe-7z
@@ -262,7 +262,7 @@ jobs:
           retention-days: 7
 
       - name: Upload Windows arm64 install failure logs
-        if: failure() && matrix.os == 'windows-11-arm'
+        if: failure() && matrix.os == 'windows-11-vs2026-arm'
         uses: actions/upload-artifact@v7
         with:
           name: mesh-client-win-arm64-install-logs-${{ github.sha }}

.github/workflows/release.yaml

@@ -345,7 +345,7 @@ jobs:
             label: x64 NSIS install
             artifact: mesh-client-windows-${{ github.sha }}
             smoke_run: node scripts/test-win-nsis-install.mjs --arch x64
-          - os: windows-11-arm
+          - os: windows-11-vs2026-arm
             label: arm64 NSIS install (WoA)
             artifact: mesh-client-windows-${{ github.sha }}
             smoke_run: node scripts/test-win-nsis-install.mjs --arch arm64 --probe-7z
@@ -381,7 +381,7 @@ jobs:
           retention-days: 7
 
       - name: Upload Windows arm64 install failure logs
-        if: failure() && matrix.os == 'windows-11-arm'
+        if: failure() && matrix.os == 'windows-11-vs2026-arm'
         uses: actions/upload-artifact@v7
         with:
           name: mesh-client-win-arm64-install-logs-${{ github.sha }}

docs/agents/ble-serial.md

@@ -9,7 +9,8 @@ Meshtastic and MeshCore share LoRa BLE reconnect contracts whenever possible (pl
 - **`rfReconnectController`** (`lib/rfReconnectController.ts`): single-owner link-lost / schedule / endAttempt for both runtimes (MeshCore TCP uses the same owner; conn side effects must not call `handleConnectionLost` for TCP).
 - **`gattSetupInflight`** in `noble-ble-manager` (both session ids): after `connectAsync`, mid-GATT disconnect rejects in-flight `connect()` promptly (Noble only).
 - **Deferred Noble disconnect** while connect/reconnect open is in flight; **flush in reconnect `finally`** in `useMeshtasticRuntime` and `useMeshcoreRuntime` so edge-of-range drops keep retrying.
-- **`NOBLE_BLE_RECONNECT_ATTEMPT_BUDGET_MS`** (`timeConstants.ts`) + `raceWithDeadline` (`bleReconnectHelper.ts`): hard ceiling per BLE reconnect open+handshake attempt on **all platforms** (unsticks configure/attach hangs; does not add a Linux cross-protocol mutex).
+- **`NOBLE_BLE_RECONNECT_ATTEMPT_BUDGET_MS`** (`timeConstants.ts`, 2× `MESHTASTIC_BLE_CONFIGURE_TIMEOUT_MS`) + `raceWithDeadline` (`bleReconnectHelper.ts`): hard ceiling per BLE reconnect open+handshake attempt on **all platforms** (unsticks configure/attach hangs; does not add a Linux cross-protocol mutex).
+- **Meshtastic BLE configure stall watchdog:** `MESHTASTIC_BLE_CONFIGURE_TIMEOUT_MS` (60s) in `meshtasticRuntimeWireEffects.ts`; timer resets on NodeDB replay progress via `touchMeshtasticConfigureProgress()` from `nodeStore` (`node_info`, position, telemetry — not synthetic UserPackets).
 - **Mutex:** Noble IPC connects still go through `withNobleBleConnectMutex()` — budget must not leave that mutex held (timeout clears in-flight flags; late open losers are ignored via attempt-active / generation guards).
 - MeshCore must **not** start the runtime reconnect loop on disconnect before the first successful configure — ConnectionPanel `reconnectBleWithScan` owns initial retries (`meshcoreEverConfiguredRef`). **Manual disconnect** (`connectionStore.disconnectIntent`) must **not** auto-reconnect — covered by `useMeshcoreRuntime.reconnect.test.ts`, `useMeshtasticRuntime.reconnect-hardening.test.ts`, and `useReticulumRuntime.reconnect-hardening.test.ts`.
 

docs/agents/meshtastic.md

@@ -9,5 +9,5 @@ Deep subsystem reference for AI assistants. Open this when a task touches Meshta
 - **S&F chat history:** `src/renderer/lib/meshtasticBacklogUtils.ts` — `CLIENT_HISTORY` on primary router heartbeat after RF configure (auto: 50-msg cap, 120 min window cap, 15 min per-server cooldown, 5 min offline gate; `storeForwardAutoFetchHistory` opt-out; `storeForwardHistoryProfile: 'conservative' | 'aggressive'` in `defaultAppSettings.ts` tunes offline gate / cooldown / cap aggressiveness; manual catch-up in Chat). Protobuf decode for replayed text, `via_store_forward` on messages; do not await SDK queue for history (async replay).
 - **MQTT broker clientId:** `src/main/mqtt-broker-client-id.ts` — stable per-install IDs in `app_settings` (`meshtasticMqttClientId`, `meshcoreMqttClientId`); MeshCore LetsMesh `v1_` username unchanged as clientId.
 - **PKC remote admin (firmware 2.5+):** `meshtasticRemoteAdmin.ts` — PKI-wrapped `AdminMessage` via `MeshDevice.sendRaw()` (`pkiEncrypted: true`, channel omitted on wire); session passkeys (~300s); tab-scoped snapshot routes in `meshtasticRemoteAdminSnapshot.ts` (Channels-first LoRa load). Per-node keys: `meshtasticRemoteAdminKeyStorage.ts` (`meshtasticRemoteAdminKey:<nodeNum>` in `app_settings`; base64 / `base64:` / 64-char hex paste). Dest public key: NodeDB hex first, stored admin-key base64 fallback. `useMeshtasticRuntime`: `configureTargetNodeNum`, `remoteConfigSnapshot`, `runRemoteAdminOp` (errors → UI + toast); serialize admin reads with S&F (`remoteAdminReadsActiveCount` in `meshtasticBacklogUtils.ts`). **Requires connected local radio** (MQTT-only cannot admin). UI: `ConfigureNodeSelector.tsx`; NodeDetailModal admin key + **Configure node remotely**; SecurityPanel **Copy** public key. Persist last target in `meshtasticConfigureTargetNodeNum`. Gate with `hasRemoteAdmin`. Legacy admin channel (PSK + `"admin"`) out of scope.
-- **Meshtastic last heard:** `meshtasticLastHeard.ts` — bump `last_heard` on live RF packets (not only text); `computeNodeInfoLastHeardMs` prevents configure replay from regressing fresher client timestamps.
+- **Meshtastic last heard:** `meshtasticLastHeard.ts` — bump `last_heard` on live RF packets (not only text); `computeNodeInfoLastHeardMs` merges radio NodeDB timestamps with client-side values (max wins). **Configure replay guard** must apply in `nodeStore` (`upsertNode`, `updatePosition`, `meshtasticLastHeardPatch`) via `meshtasticConfigurePhase.ts`, not only in `meshtasticNodeSideEffects` — PacketRouter updates the store before side effects run. During `device.configure()`, the Meshtastic SDK replays NodeDB as `node_info` frames and may emit synthetic `onUserPacket` / `onPositionPacket` with `rxTime = now`; guards skip those bumps. UserPacket path uses `mergeMeshtasticUserPacketLastHeard` (ms); NodeDB path uses `computeNodeInfoLastHeardMs` (sec). SQLite stores `last_heard` as unix seconds; `meshtasticDbCacheHydration.ts` normalizes to ms on hydrate (`normalizeLastHeardMs`); stale/online checks use `effectiveLastHeardMs`. BLE configure uses a **stall watchdog** (`MESHTASTIC_BLE_CONFIGURE_TIMEOUT_MS`, reset on each replayed `node_info` / position / telemetry via `touchMeshtasticConfigureProgress`) so large NodeDBs are not cut off mid-stream. Node list JSON export emits `last_heard` as unix seconds with `last_heard_unit: 'unix_sec'`.
 - **Static GPS:** `src/renderer/lib/gpsSource.ts` — App tab static coordinates sync to self-node, map, and radio `setPosition`.

docs/ci-cd.md

@@ -268,7 +268,7 @@ node scripts/run-act.mjs ci -- -n
 | Windows `.exe`                          | —                      | —                           | —                      | `pnpm run dist:win`    |
 | Flatpak x86_64                          | `act:flatpak`          | use local Flatpak docs      | same                   | same                   |
 
-**Not run locally via act:** `docs.yml` (`mkdocs gh-deploy`), release publish legs, `macos-latest` / `windows-latest` / `windows-11-arm` matrix jobs, and `ubuntu-24.04-arm` Flatpak builds (no faithful local emulation).
+**Not run locally via act:** `docs.yml` (`mkdocs gh-deploy`), release publish legs, `macos-latest` / `windows-latest` / `windows-11-vs2026-arm` matrix jobs, and `ubuntu-24.04-arm` Flatpak builds (no faithful local emulation).
 
 Note: The test results artifact upload step is automatically skipped when running under `act` (detected by actor `nektos/act` in [`tests.yaml`](../.github/workflows/tests.yaml)).
 

docs/release-process.md

@@ -183,7 +183,7 @@ After builds finish, **`packaging-smoke`** runs on:
 - macOS — `verify-mac-packaging.mjs` (includes bundled Reticulum sidecar in `.app`)
 - Linux — `verify-linux-packaging.mjs` plus `test-linux-appimage-reticulum-sidecar.mjs` (extracts x64/arm64 AppImages and asserts sidecar). **`verify-linux-packaging.mjs`** also asserts each `.deb` **Description** field is ASCII-only (no mojibake `??`) via `dpkg-deb -f` — non-ASCII control metadata breaks some package managers and mirrors.
 - Windows x64 — NSIS install smoke test (`test-win-nsis-install.mjs`, asserts sidecar after install)
-- **`windows-11-arm`** — arm64 NSIS install smoke test with 7z probe (asserts sidecar inside installer payload and after install)
+- **`windows-11-vs2026-arm`** — arm64 NSIS install smoke test with 7z probe (asserts sidecar inside installer payload and after install). Uses GitHub's advance-testing WoA runner ahead of the Sept 2026 VS 2026 rollout on `windows-11-arm`.
 
 Build jobs also run `verify-reticulum-sidecar-staged.mjs` after staging sidecars and before `electron-builder`.
 

src/main/windows-packaging.contract.test.ts

@@ -159,7 +159,7 @@ describe('Windows packaging (contract)', () => {
     expect(buildWorkflow).toContain('label: x64 NSIS install');
     expect(buildWorkflow).toContain('node scripts/test-win-nsis-install.mjs --arch x64');
     expect(buildWorkflow).toContain('label: arm64 NSIS install (WoA)');
-    expect(buildWorkflow).toContain('- os: windows-11-arm');
+    expect(buildWorkflow).toContain('- os: windows-11-vs2026-arm');
     expect(buildWorkflow).toContain(
       'node scripts/test-win-nsis-install.mjs --arch arm64 --probe-7z',
     );
@@ -215,7 +215,7 @@ describe('Windows packaging (contract)', () => {
     expect(releaseWorkflow).toContain('label: x64 NSIS install');
     expect(releaseWorkflow).toContain('node scripts/test-win-nsis-install.mjs --arch x64');
     expect(releaseWorkflow).toContain('label: arm64 NSIS install (WoA)');
-    expect(releaseWorkflow).toContain('- os: windows-11-arm');
+    expect(releaseWorkflow).toContain('- os: windows-11-vs2026-arm');
     expect(releaseWorkflow).toContain(
       'node scripts/test-win-nsis-install.mjs --arch arm64 --probe-7z',
     );

src/renderer/components/NodeListPanel.test.tsx

@@ -103,6 +103,12 @@ vi.mock('./Toast', () => ({
   }),
 }));
 
+vi.mock('../lib/downloadBlob', () => ({
+  downloadBlob: vi.fn(),
+}));
+
+import { downloadBlob } from '../lib/downloadBlob';
+
 const defaultFilter = {
   enabled: false,
   maxDistance: 500,
@@ -858,6 +864,39 @@ describe('NodeListPanel meshtastic node id display', () => {
   });
 });
 
+describe('NodeListPanel JSON export', () => {
+  beforeEach(() => {
+    vi.mocked(downloadBlob).mockClear();
+  });
+
+  it('exports millisecond last_heard as unix seconds with last_heard_unit', async () => {
+    const user = userEvent.setup();
+    const lastHeardMs = 1_700_000_000_000;
+    const nodes = new Map<number, MeshNode>([
+      [42, makeNode({ node_id: 42, long_name: 'Export Node', last_heard: lastHeardMs })],
+    ]);
+    render(
+      <NodeListPanel
+        nodes={nodes}
+        myNodeNum={0}
+        onNodeClick={vi.fn()}
+        locationFilter={defaultFilter}
+        onToggleFavorite={vi.fn()}
+        mode="meshtastic"
+      />,
+    );
+    await user.click(screen.getByRole('button', { name: 'Export JSON' }));
+    expect(downloadBlob).toHaveBeenCalledTimes(1);
+    const [blob] = vi.mocked(downloadBlob).mock.calls[0];
+    const text = await blob.text();
+    const parsed = JSON.parse(text) as {
+      nodes: { last_heard: number; last_heard_unit: string }[];
+    };
+    expect(parsed.nodes[0]?.last_heard).toBe(1_700_000_000);
+    expect(parsed.nodes[0]?.last_heard_unit).toBe('unix_sec');
+  });
+});
+
 describe('NodeListPanel show on map', () => {
   beforeEach(() => {
     positionHistoryStoreState.history = new Map();

src/renderer/components/NodeListPanel.tsx

@@ -75,7 +75,12 @@ import {
 } from '../lib/meshtasticSourceIcons';
 import { nodeHealthScore, nodeHealthTier } from '../lib/nodeHealthScore';
 import { getNodeTypeIcon } from '../lib/nodeIcons';
-import { getNodeStatus, haversineDistanceKm, normalizeLastHeardMs } from '../lib/nodeStatus';
+import {
+  getNodeStatus,
+  haversineDistanceKm,
+  lastHeardToUnixSeconds,
+  normalizeLastHeardMs,
+} from '../lib/nodeStatus';
 import { getOfflineIdentityIdForProtocol } from '../lib/offlineProtocolIdentities';
 import { useRadioProvider } from '../lib/radio/providerFactory';
 import { RoleDisplay } from '../lib/roleInfo';
@@ -816,7 +821,8 @@ export default function NodeListPanel({
                 rssi: n.rssi,
                 battery: n.battery,
                 voltage: n.voltage,
-                last_heard: n.last_heard,
+                last_heard: lastHeardToUnixSeconds(n.last_heard),
+                last_heard_unit: 'unix_sec',
                 latitude: n.latitude,
                 longitude: n.longitude,
                 altitude: n.altitude,

src/renderer/hooks/useMeshtasticRuntime.configure-rejection.test.tsx

@@ -3,7 +3,13 @@ import { renderHook, waitFor } from '@testing-library/react';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
 import * as connection from '../lib/connection';
+import { getMeshtasticConfigurePhase } from '../lib/meshtastic/meshtasticConfigurePhase';
+import { meshtasticProtocol } from '../lib/protocols/MeshtasticProtocol';
+import { MS_PER_DAY } from '../lib/timeConstants';
 import { useMeshtasticRuntime } from '../runtime/useMeshtasticRuntime';
+import { setConnection } from '../stores/connectionStore';
+import { addIdentity } from '../stores/identityStore';
+import { upsertNode, useNodeStore } from '../stores/nodeStore';
 
 vi.mock('../lib/connection', () => ({
   createBleConnection: vi.fn(),
@@ -50,4 +56,50 @@ describe('useMeshtasticRuntime — configure() rejection', () => {
       expect(result.current.state.status).toBe('disconnected');
     });
   });
+
+  it('clears configure phase after rejected configure so live node updates bump last_heard', async () => {
+    const ID = 'id-config-reject-live';
+    const PEER = 42;
+    const staleMs = Date.now() - 7 * MS_PER_DAY;
+    const liveMs = Date.now() - 60_000;
+
+    useNodeStore.setState({ nodes: {}, traceRoutes: {}, waypoints: {}, neighborInfo: {} });
+    addIdentity({
+      id: ID,
+      protocol: meshtasticProtocol,
+      signature: 'meshtastic:config-reject',
+      transports: [],
+      createdAt: Date.now(),
+      lastSeenAt: Date.now(),
+    });
+    setConnection(ID, { myNodeNum: 1, status: 'connected', connectionType: 'http' });
+    useNodeStore.setState({
+      nodes: { [ID]: { [PEER]: { nodeId: PEER, lastHeardAt: staleMs } } },
+      traceRoutes: {},
+      waypoints: {},
+      neighborInfo: {},
+    });
+
+    const err = new Error('Configure stalled');
+    const device = createStubDevice(vi.fn().mockRejectedValue(err));
+    vi.mocked(connection.createConnection).mockResolvedValue(device);
+
+    const { result } = renderHook(() => useMeshtasticRuntime());
+
+    await expect(result.current.connect('http', 'http://127.0.0.1')).rejects.toThrow(
+      'Configure stalled',
+    );
+
+    await waitFor(() => {
+      expect(getMeshtasticConfigurePhase()).toBe(false);
+    });
+
+    upsertNode(ID, {
+      nodeId: PEER,
+      fromUserPacket: true,
+      lastHeardAt: liveMs,
+      longName: 'Peer',
+    });
+    expect(useNodeStore.getState().nodes[ID][PEER].lastHeardAt).toBe(liveMs);
+  });
 });

src/renderer/lib/buildMeshPeerTopologyGraph.test.ts

@@ -176,6 +176,12 @@ describe('isMeshPeerOnline', () => {
   it('treats recently heard nodes as online', () => {
     expect(isMeshPeerOnline(node(1, { last_heard: Date.now() - 1000 }))).toBe(true);
   });
+
+  it('treats sec-valued last_heard from DB hydration as recently heard', () => {
+    const nowMs = Date.now();
+    const secHeard = Math.floor((nowMs - 30 * 60_000) / 1000);
+    expect(isMeshPeerOnline(node(1, { last_heard: secHeard }), nowMs)).toBe(true);
+  });
 });
 
 function peerMap(peerCount: number, hopsAway: number | undefined): Map<number, MeshNode> {

src/renderer/lib/buildMeshPeerTopologyGraph.ts

@@ -1,5 +1,6 @@
 import type { ForceEdge } from './forceDirectedGraphLayout';
 import { nodeHealthScore, type NodeHealthTier, nodeHealthTier } from './nodeHealthScore';
+import { effectiveLastHeardMs } from './nodeStatus';
 import { MS_PER_HOUR } from './timeConstants';
 import {
   MESH_TOPOLOGY_NEARBY_MAX_HOPS,
@@ -75,7 +76,9 @@ export function isMeshPeerOnline(node: MeshNode, nowMs: number = Date.now()): bo
   if (hops != null && hops >= 0) return true;
   const lastHeard = node.last_heard;
   if (lastHeard <= 0) return false;
-  return nowMs - lastHeard < MS_PER_HOUR;
+  const effectiveMs = effectiveLastHeardMs(lastHeard, nowMs);
+  if (!effectiveMs) return false;
+  return nowMs - effectiveMs < MS_PER_HOUR;
 }
 
 function nodeLabel(node: MeshNode): string {

src/renderer/lib/meshtastic/meshtasticConfigurePhase.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import {
+  getMeshtasticConfigurePhase,
+  resetMeshtasticConfigurePhaseForTests,
+  setMeshtasticConfigurePhase,
+  setMeshtasticConfigureProgressHandler,
+  touchMeshtasticConfigureProgress,
+} from './meshtasticConfigurePhase';
+
+describe('meshtasticConfigurePhase', () => {
+  it('keeps progress handler after configure ends so refresh can reset stall timer', () => {
+    resetMeshtasticConfigurePhaseForTests();
+    const onProgress = vi.fn();
+    setMeshtasticConfigureProgressHandler(onProgress);
+
+    setMeshtasticConfigurePhase(true);
+    touchMeshtasticConfigureProgress();
+    expect(onProgress).toHaveBeenCalledTimes(1);
+
+    setMeshtasticConfigurePhase(false);
+    expect(getMeshtasticConfigurePhase()).toBe(false);
+
+    setMeshtasticConfigurePhase(true);
+    touchMeshtasticConfigureProgress();
+    expect(onProgress).toHaveBeenCalledTimes(2);
+  });
+
+  it('does not invoke progress handler when configure phase is inactive', () => {
+    resetMeshtasticConfigurePhaseForTests();
+    const onProgress = vi.fn();
+    setMeshtasticConfigureProgressHandler(onProgress);
+
+    touchMeshtasticConfigureProgress();
+    expect(onProgress).not.toHaveBeenCalled();
+  });
+});

src/renderer/lib/meshtastic/meshtasticConfigurePhase.ts

@@ -0,0 +1,30 @@
+/** Meshtastic device.configure / NodeDB replay phase — shared by nodeStore and wireEffects. */
+
+let configuring = false;
+let onConfigureProgress: (() => void) | null = null;
+
+export function setMeshtasticConfigurePhase(value: boolean): void {
+  configuring = value;
+  // Progress handler lifetime == wire attach lifetime (cleared on detach / test reset only).
+}
+
+export function getMeshtasticConfigurePhase(): boolean {
+  return configuring;
+}
+
+/** Register BLE configure stall watchdog reset (wireEffects only). */
+export function setMeshtasticConfigureProgressHandler(handler: (() => void) | null): void {
+  onConfigureProgress = handler;
+}
+
+/** Reset configure stall timer while NodeDB / FromRadio frames still arrive. */
+export function touchMeshtasticConfigureProgress(): void {
+  if (!configuring) return;
+  onConfigureProgress?.();
+}
+
+/** Test-only reset. */
+export function resetMeshtasticConfigurePhaseForTests(): void {
+  configuring = false;
+  onConfigureProgress = null;
+}