feat(position-estimation): max-accuracy cutoff + gate circles by Show Accuracy

Two follow-ups addressing oversized estimated-position uncertainty circles.

1. Maximum Acceptable Accuracy setting. New global setting
   position_estimation_max_uncertainty_km (0 = no limit). When set, the
   scheduler passes it to recomputeAll, which discards any solved estimate
   whose uncertainty radius exceeds the ceiling rather than storing it — and
   deletes that node's stale estimate so a now-too-uncertain node doesn't keep
   an oversized circle. Surfaced in the global Settings → Position Estimation
   section with a km input and reflected in the last-run summary (N discarded).

   The dominant "huge circle" case is the 5km single-anchor default
   (DEFAULT_SINGLE_ANCHOR_KM); a 2-3km cutoff drops those low-confidence guesses.

2. Gate the estimated-position uncertainty circles behind the existing
   "Show Accuracy" map toggle (showAccuracyRegions) instead of
   "Show Estimated Positions". Now one control governs every accuracy overlay
   (precision-bits rectangles + estimated-position circles); the estimated
   markers stay under "Show Estimated Positions". Both are required so a circle
   never renders without its marker.

Tests: scheduler passes maxUncertaintyKm through (incl. 0=no-limit default);
service discards over-threshold estimates + clears stale rows, keeps within-
threshold, and treats 0 as unlimited.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: Yeraze

src/components/NodesTab.tsx

@@ -2172,8 +2172,12 @@ const NodesTabComponent: React.FC<NodesTabProps> = ({
                 );
               })}
 
-              {/* Draw uncertainty circles for estimated positions */}
-              {showEstimatedPositions && nodesWithPosition
+              {/* Draw uncertainty circles for estimated positions. The "Show
+                  Accuracy" map toggle now governs the radius (issue #3271
+                  follow-up) — turning it off declutters the circles while the
+                  estimated-node markers stay under "Show Estimated Positions".
+                  Both are required so a circle never renders without its marker. */}
+              {showEstimatedPositions && showAccuracyRegions && nodesWithPosition
                 .filter(node => node.user?.id && nodesWithEstimatedPosition.has(node.user.id) && nodePassesTransportFilter(node, { showRfNodes, showUdpNodes, showMqttNodes }) && (showIncompleteNodes || isNodeComplete(node)) && (!tracerouteNodeNums || tracerouteNodeNums.has(node.nodeNum)))
                 .map(node => {
                   // Use the real multilateration uncertainty radius (issue #3271) when

src/components/PositionEstimationSection.tsx

@@ -14,11 +14,13 @@ interface EstimationStatus {
   enabled: boolean;
   frequencyHours: number;
   lookbackHours: number;
+  maxUncertaintyKm: number;
   lastRunTime: number | null;
   lastRunResult: {
     estimatedNodeCount: number;
     observationCount: number;
     anchorCount: number;
+    rejectedNodeCount?: number;
     durationMs: number;
   } | null;
 }
@@ -40,10 +42,12 @@ const PositionEstimationSection: React.FC<PositionEstimationSectionProps> = ({ b
   const [enabled, setEnabled] = useState(true);
   const [frequencyHours, setFrequencyHours] = useState(6);
   const [lookbackHours, setLookbackHours] = useState(168);
+  const [maxUncertaintyKm, setMaxUncertaintyKm] = useState(0);
 
   const [localEnabled, setLocalEnabled] = useState(true);
   const [localFrequencyHours, setLocalFrequencyHours] = useState(6);
   const [localLookbackHours, setLocalLookbackHours] = useState(168);
+  const [localMaxUncertaintyKm, setLocalMaxUncertaintyKm] = useState(0);
 
   const [status, setStatus] = useState<EstimationStatus | null>(null);
   const [isSaving, setIsSaving] = useState(false);
@@ -58,9 +62,11 @@ const PositionEstimationSection: React.FC<PositionEstimationSectionProps> = ({ b
         setEnabled(data.enabled);
         setFrequencyHours(data.frequencyHours);
         setLookbackHours(data.lookbackHours);
+        setMaxUncertaintyKm(data.maxUncertaintyKm ?? 0);
         setLocalEnabled(data.enabled);
         setLocalFrequencyHours(data.frequencyHours);
         setLocalLookbackHours(data.lookbackHours);
+        setLocalMaxUncertaintyKm(data.maxUncertaintyKm ?? 0);
       }
     } catch {
       // Status is non-critical; ignore fetch failures.
@@ -74,7 +80,8 @@ const PositionEstimationSection: React.FC<PositionEstimationSectionProps> = ({ b
   const hasChanges =
     localEnabled !== enabled ||
     localFrequencyHours !== frequencyHours ||
-    localLookbackHours !== lookbackHours;
+    localLookbackHours !== lookbackHours ||
+    localMaxUncertaintyKm !== maxUncertaintyKm;
 
   const handleSave = useCallback(async () => {
     setIsSaving(true);
@@ -86,12 +93,14 @@ const PositionEstimationSection: React.FC<PositionEstimationSectionProps> = ({ b
           position_estimation_enabled: String(localEnabled),
           position_estimation_frequency_hours: String(localFrequencyHours),
           position_estimation_lookback_hours: String(localLookbackHours),
+          position_estimation_max_uncertainty_km: String(localMaxUncertaintyKm),
         }),
       });
       if (response.ok) {
         setEnabled(localEnabled);
         setFrequencyHours(localFrequencyHours);
         setLookbackHours(localLookbackHours);
+        setMaxUncertaintyKm(localMaxUncertaintyKm);
         showToast(t('automation.settings_saved', 'Settings saved'), 'success');
       } else {
         showToast(t('automation.settings_save_failed', 'Failed to save'), 'error');
@@ -101,13 +110,14 @@ const PositionEstimationSection: React.FC<PositionEstimationSectionProps> = ({ b
     } finally {
       setIsSaving(false);
     }
-  }, [localEnabled, localFrequencyHours, localLookbackHours, csrfFetch, baseUrl, showToast, t]);
+  }, [localEnabled, localFrequencyHours, localLookbackHours, localMaxUncertaintyKm, csrfFetch, baseUrl, showToast, t]);
 
   const resetChanges = useCallback(() => {
     setLocalEnabled(enabled);
     setLocalFrequencyHours(frequencyHours);
     setLocalLookbackHours(lookbackHours);
-  }, [enabled, frequencyHours, lookbackHours]);
+    setLocalMaxUncertaintyKm(maxUncertaintyKm);
+  }, [enabled, frequencyHours, lookbackHours, maxUncertaintyKm]);
 
   useSaveBar({
     id: 'position-estimation',
@@ -226,6 +236,26 @@ const PositionEstimationSection: React.FC<PositionEstimationSectionProps> = ({ b
           </select>
         </div>
 
+        <div className="setting-item" style={{ marginTop: '1rem' }}>
+          <label>{t('automation.position_estimation.max_uncertainty', 'Maximum acceptable accuracy (km)')}</label>
+          <input
+            type="number"
+            min={0}
+            step={0.5}
+            value={localMaxUncertaintyKm}
+            onChange={(e) => {
+              const v = parseFloat(e.target.value);
+              setLocalMaxUncertaintyKm(Number.isFinite(v) && v > 0 ? v : 0);
+            }}
+            disabled={!localEnabled}
+            className="setting-input"
+          />
+          <p style={{ fontSize: '12px', color: 'var(--ctp-subtext0)', margin: '0.35rem 0 0 0' }}>
+            {t('automation.position_estimation.max_uncertainty_help',
+              'Estimates with an uncertainty radius larger than this are discarded rather than stored, so low-confidence guesses don’t draw huge circles on the map. Set 0 for no limit.')}
+          </p>
+        </div>
+
         {status && (
           <div style={{ marginTop: '1.5rem', marginLeft: '1.75rem', fontSize: '13px', color: 'var(--ctp-subtext1)' }}>
             <div>
@@ -240,6 +270,15 @@ const PositionEstimationSection: React.FC<PositionEstimationSectionProps> = ({ b
                   anchors: status.lastRunResult.anchorCount,
                   defaultValue: `${status.lastRunResult.estimatedNodeCount} node(s) estimated from ${status.lastRunResult.observationCount} observation(s), ${status.lastRunResult.anchorCount} anchor(s)`,
                 })}
+                {status.lastRunResult.rejectedNodeCount ? (
+                  <>
+                    {' '}
+                    {t('automation.position_estimation.last_rejected', {
+                      count: status.lastRunResult.rejectedNodeCount,
+                      defaultValue: `(${status.lastRunResult.rejectedNodeCount} discarded over max accuracy)`,
+                    })}
+                  </>
+                ) : null}
               </div>
             )}
           </div>

src/server/constants/settings.ts

@@ -100,6 +100,9 @@ export const VALID_SETTINGS_KEYS = [
   'position_estimation_enabled',
   'position_estimation_frequency_hours',
   'position_estimation_lookback_hours',
+  // Max acceptable uncertainty (km). Estimates whose computed radius exceeds
+  // this are discarded rather than stored (issue #3271 follow-up). 0 = no limit.
+  'position_estimation_max_uncertainty_km',
   'autoKeyManagementEnabled',
   'autoKeyManagementIntervalMinutes',
   'autoKeyManagementMaxExchanges',

src/server/services/positionEstimationScheduler.test.ts

@@ -17,6 +17,7 @@ import {
   isRunDue,
   positionEstimationScheduler,
   DEFAULT_FREQUENCY_HOURS,
+  DEFAULT_LOOKBACK_HOURS,
 } from './positionEstimationScheduler.js';
 
 const HOUR = 60 * 60 * 1000;
@@ -50,14 +51,24 @@ describe('positionEstimationScheduler.runNow', () => {
     mockDb.settings.setSetting.mockResolvedValue(undefined);
   });
 
-  it('invokes recomputeAll with the configured lookback window', async () => {
+  it('invokes recomputeAll with the configured lookback window and max uncertainty', async () => {
     mockDb.settings.getSetting.mockImplementation(async (key: string) => {
       if (key === 'position_estimation_lookback_hours') return '48';
+      if (key === 'position_estimation_max_uncertainty_km') return '3';
       return null;
     });
     await positionEstimationScheduler.runNow();
     expect(mockService.positionEstimationService.recomputeAll).toHaveBeenCalledWith({
       lookbackMs: 48 * HOUR,
+      maxUncertaintyKm: 3,
+    });
+  });
+
+  it('passes maxUncertaintyKm: 0 (no limit) when the setting is unset', async () => {
+    await positionEstimationScheduler.runNow();
+    expect(mockService.positionEstimationService.recomputeAll).toHaveBeenCalledWith({
+      lookbackMs: DEFAULT_LOOKBACK_HOURS * HOUR,
+      maxUncertaintyKm: 0,
     });
   });
 

src/server/services/positionEstimationScheduler.ts

@@ -22,6 +22,9 @@ const LAST_RUN_KEY = 'position_estimation_last_run';
 
 export const DEFAULT_FREQUENCY_HOURS = 6;
 export const DEFAULT_LOOKBACK_HOURS = 168; // 7 days
+// 0 = no limit (store every solvable estimate). Opt-in: the operator sets a
+// km ceiling to drop low-confidence estimates that draw huge map circles.
+export const DEFAULT_MAX_UNCERTAINTY_KM = 0;
 const MIN_FREQUENCY_HOURS = 0.5;
 const MIN_LOOKBACK_HOURS = 1;
 const CHECK_INTERVAL_MS = 60_000;
@@ -41,6 +44,7 @@ export interface EstimationStatus {
   enabled: boolean;
   frequencyHours: number;
   lookbackHours: number;
+  maxUncertaintyKm: number;
   lastRunTime: number | null;
   lastRunResult: RecomputeResult | null;
 }
@@ -103,6 +107,15 @@ class PositionEstimationScheduler {
     return raw;
   }
 
+  private async getMaxUncertaintyKm(): Promise<number> {
+    const raw = parseFloat(
+      (await databaseService.settings.getSetting('position_estimation_max_uncertainty_km')) || String(DEFAULT_MAX_UNCERTAINTY_KM)
+    );
+    // Treat invalid/negative as "no limit" (0).
+    if (!Number.isFinite(raw) || raw < 0) return DEFAULT_MAX_UNCERTAINTY_KM;
+    return raw;
+  }
+
   private async getLastRun(): Promise<number | null> {
     if (this.lastRunTime !== null) return this.lastRunTime;
     const stored = await databaseService.settings.getSetting(LAST_RUN_KEY);
@@ -143,9 +156,13 @@ class PositionEstimationScheduler {
   private async execute(): Promise<RecomputeResult> {
     this.inProgress = true;
     try {
-      const lookbackHours = await this.getLookbackHours();
+      const [lookbackHours, maxUncertaintyKm] = await Promise.all([
+        this.getLookbackHours(),
+        this.getMaxUncertaintyKm(),
+      ]);
       const result = await positionEstimationService.recomputeAll({
         lookbackMs: lookbackHours * 60 * 60 * 1000,
+        maxUncertaintyKm,
       });
       this.lastRunResult = result;
       return result;
@@ -161,10 +178,11 @@ class PositionEstimationScheduler {
   }
 
   async getStatus(): Promise<EstimationStatus> {
-    const [enabled, frequencyHours, lookbackHours, lastRun] = await Promise.all([
+    const [enabled, frequencyHours, lookbackHours, maxUncertaintyKm, lastRun] = await Promise.all([
       this.getEnabled(),
       this.getFrequencyHours(),
       this.getLookbackHours(),
+      this.getMaxUncertaintyKm(),
       this.getLastRun(),
     ]);
     return {
@@ -173,6 +191,7 @@ class PositionEstimationScheduler {
       enabled,
       frequencyHours,
       lookbackHours,
+      maxUncertaintyKm,
       lastRunTime: lastRun,
       lastRunResult: this.lastRunResult,
     };

src/server/services/positionEstimationService.test.ts

@@ -254,4 +254,51 @@ describe('positionEstimationService.recomputeAll', () => {
     expect(deletedNodeNums).toContain(100);
     expect(deletedNodeNums).toContain(200);
   });
+
+  describe('maxUncertaintyKm threshold (issue #3271 follow-up)', () => {
+    // A single-anchor neighbor observation yields the DEFAULT_SINGLE_ANCHOR_KM
+    // (5 km) uncertainty — the dominant "huge circle" case.
+    const singleAnchorSetup = () => {
+      mockDb.sources.getAllSources.mockResolvedValue([{ id: 's', type: 'meshtastic_tcp' }]);
+      mockDb.nodes.getAllNodes.mockResolvedValue([{ nodeNum: 100, latitude: 10, longitude: 20 }]);
+      mockDb.neighbors.getAllNeighborInfo.mockResolvedValue([
+        { nodeNum: 100, neighborNodeNum: 5, snr: 10, timestamp: NOW },
+      ]);
+    };
+
+    it('discards an estimate whose uncertainty exceeds the maximum and clears any stale row', async () => {
+      singleAnchorSetup();
+      const result = await positionEstimationService.recomputeAll({
+        lookbackMs: 7 * 24 * 60 * 60 * 1000,
+        maxUncertaintyKm: 3, // 5km estimate > 3km ceiling → rejected
+      });
+      expect(result.estimatedNodeCount).toBe(0);
+      expect(result.rejectedNodeCount).toBe(1);
+      // Nothing stored for the over-threshold node...
+      expect(mockDb.upsertEstimatedPositionsAsync.mock.calls[0][0]).toHaveLength(0);
+      // ...and its existing estimate (if any) is cleared.
+      expect(mockDb.deleteEstimatedPositionsByNodeNumsAsync.mock.calls[0][0]).toContain(5);
+    });
+
+    it('keeps an estimate within the maximum', async () => {
+      singleAnchorSetup();
+      const result = await positionEstimationService.recomputeAll({
+        lookbackMs: 7 * 24 * 60 * 60 * 1000,
+        maxUncertaintyKm: 10, // 5km estimate ≤ 10km ceiling → kept
+      });
+      expect(result.estimatedNodeCount).toBe(1);
+      expect(result.rejectedNodeCount).toBe(0);
+      expect(mockDb.upsertEstimatedPositionsAsync.mock.calls[0][0]).toHaveLength(1);
+    });
+
+    it('treats maxUncertaintyKm 0 as no limit', async () => {
+      singleAnchorSetup();
+      const result = await positionEstimationService.recomputeAll({
+        lookbackMs: 7 * 24 * 60 * 60 * 1000,
+        maxUncertaintyKm: 0,
+      });
+      expect(result.estimatedNodeCount).toBe(1);
+      expect(result.rejectedNodeCount).toBe(0);
+    });
+  });
 });

src/server/services/positionEstimationService.ts

@@ -46,6 +46,9 @@ export interface RecomputeResult {
   estimatedNodeCount: number;
   observationCount: number;
   anchorCount: number;
+  /** Solved positions discarded because their uncertainty exceeded the
+   *  configured maximum (issue #3271 follow-up). */
+  rejectedNodeCount: number;
   durationMs: number;
 }
 
@@ -279,10 +282,13 @@ class PositionEstimationService {
    * window. Pools every Meshtastic source (MeshCore excluded). Bulk-upserts
    * results and clears estimates for nodes that now have real positions.
    */
-  async recomputeAll(opts: { lookbackMs: number }): Promise<RecomputeResult> {
+  async recomputeAll(opts: { lookbackMs: number; maxUncertaintyKm?: number | null }): Promise<RecomputeResult> {
     const start = Date.now();
     const now = start;
     const cutoff = now - opts.lookbackMs;
+    // 0 / null / negative ⇒ no limit (store every solvable estimate).
+    const maxUncertaintyKm =
+      opts.maxUncertaintyKm != null && opts.maxUncertaintyKm > 0 ? opts.maxUncertaintyKm : null;
 
     // Meshtastic-only sources (exclude MeshCore).
     const allSources = await databaseService.sources.getAllSources();
@@ -338,10 +344,18 @@ class PositionEstimationService {
 
     let observationCount = 0;
     const inputs: EstimatedPositionInput[] = [];
+    // Nodes solved but rejected for exceeding maxUncertaintyKm. Their existing
+    // estimates (if any) are deleted below so a now-too-uncertain node doesn't
+    // keep a stale, oversized circle on the map.
+    const rejectedNodeNums: number[] = [];
     for (const [nodeNum, observations] of obsByNode) {
       observationCount += observations.length;
       const solved = solveNodePosition(observations, now);
       if (!solved) continue;
+      if (maxUncertaintyKm != null && solved.uncertaintyKm > maxUncertaintyKm) {
+        rejectedNodeNums.push(nodeNum);
+        continue;
+      }
       inputs.push({
         nodeNum,
         nodeId: nodeNumToId(nodeNum),
@@ -355,20 +369,25 @@ class PositionEstimationService {
 
     await databaseService.upsertEstimatedPositionsAsync(inputs);
 
-    // A node that gained a real position should not also carry an estimate.
+    // Clear estimates that are no longer valid: a node that gained a real
+    // position (now an anchor), or one whose fresh estimate is too uncertain
+    // to keep under the configured maximum.
     const anchorNodeNums = [...anchors.keys()];
-    await databaseService.deleteEstimatedPositionsByNodeNumsAsync(anchorNodeNums);
+    await databaseService.deleteEstimatedPositionsByNodeNumsAsync([...anchorNodeNums, ...rejectedNodeNums]);
 
     const durationMs = Date.now() - start;
     logger.info(
       `📍 Position estimation: ${inputs.length} node(s) estimated from ${observationCount} observation(s) ` +
-      `across ${meshtasticSourceIds.length} source(s), ${anchors.size} anchor(s), in ${durationMs}ms`
+      `across ${meshtasticSourceIds.length} source(s), ${anchors.size} anchor(s)` +
+      (rejectedNodeNums.length ? `, ${rejectedNodeNums.length} rejected (>${maxUncertaintyKm}km)` : '') +
+      `, in ${durationMs}ms`
     );
 
     return {
       estimatedNodeCount: inputs.length,
       observationCount,
       anchorCount: anchors.size,
+      rejectedNodeCount: rejectedNodeNums.length,
       durationMs,
     };
   }