fix(lint): exclude gauge needles/pointers from connector_motion_detached

A gauge needle/pointer/tick is a one-end-anchored indicator, not a
node-to-node connector; a separate gauge check owns it. Skip a connector
whose element or group ancestor id/class matches needle|pointer|gauge|tick|
indicator, and skip gauge-indicator geometry (endpoint pivots near an SVG
arc/hub centre with the loose end radially outward). A defective radial
connector points the other way so it still fires. Clears the fuzz080 gauge
false positive; fuzz011 detach still fires (0 FP across the 81-sample corpus).

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

Author: xuanruli

packages/cli/src/commands/layout-audit.browser.js

@@ -1541,11 +1541,22 @@
   // short strokes are filtered out so only real diagram connectors count.
   const CONNECTOR_MIN_SVG_PX = 100;
   const CONNECTOR_MIN_LEN_PX = 60;
+  // Gauge needles/pointers/ticks are one-end-anchored indicators, not node-to-node
+  // connectors — a separate (gauge) check owns them. Skip by id/class of the line
+  // or any group ancestor up to the SVG.
+  const CONNECTOR_INDICATOR_NAME = /needle|pointer|gauge|tick|indicator/i;
   const CONNECTOR_NODE_MIN_AREA = 400;
   // SVG dots/markers are small; keep the floor low but above sub-pixel decoration.
   const CONNECTOR_NODE_MIN_DOT_AREA = 16;
   const CONNECTOR_NODE_CAP = 300;
 
+  function isIndicatorConnector(line, svg) {
+    for (let node = line; node && node !== svg.parentElement; node = node.parentElement) {
+      if (CONNECTOR_INDICATOR_NAME.test(connectorNameFor(node))) return true;
+    }
+    return false;
+  }
+
   function lineScreenEndpoints(svg, line) {
     if (typeof line.getScreenCTM !== "function" || typeof svg.createSVGPoint !== "function") {
       return null;
@@ -1623,6 +1634,7 @@
       for (const line of Array.from(svg.querySelectorAll("line, path"))) {
         if (line.closest(CONNECTOR_SKIP_CONTAINERS)) continue;
         if (!isVisibleElement(line, 0.05)) continue;
+        if (isIndicatorConnector(line, svg)) continue;
         const ends =
           line.tagName.toLowerCase() === "line"
             ? lineScreenEndpoints(svg, line)

packages/cli/src/utils/checkPipeline.connectorMotionDetached.test.ts

@@ -105,6 +105,56 @@ describe("detectConnectorMotionDetached", () => {
     expect(detectConnectorMotionDetached(frames, CANVAS)).toHaveLength(0);
   });
 
+  it("does not fire on a gauge needle: anchored at the arc centre, loose end radially outward", () => {
+    // Arc ring centred at 900,500; needle base on the hub near centre, tip out
+    // past the arc — a pointer, not a broken connector.
+    const hub: ConnectorNodeBox = {
+      selector: "#hub",
+      left: 890,
+      top: 490,
+      right: 910,
+      bottom: 510,
+      ring: false,
+    };
+    const arc: ConnectorNodeBox = {
+      selector: "#arc",
+      left: 700,
+      top: 300,
+      right: 1100,
+      bottom: 700,
+      ring: true,
+    };
+    const frames = [0, 2, 4, 6, 8].map((time) =>
+      frame(time, { selector: "#needle", ax: 900, ay: 500, bx: 900, by: 180 }, [hub, arc]),
+    );
+    expect(detectConnectorMotionDetached(frames, CANVAS)).toHaveLength(0);
+  });
+
+  it("still fires on a radial connector drifting toward the centre (not outward)", () => {
+    // Anchored on a peripheral node; loose end drifts inward to empty space near
+    // a ring centre — the fuzz011 shape, opposite of a gauge pointer.
+    const peripheral: ConnectorNodeBox = {
+      selector: "#panel",
+      left: 120,
+      top: 120,
+      right: 260,
+      bottom: 200,
+      ring: false,
+    };
+    const arc: ConnectorNodeBox = {
+      selector: "#arc",
+      left: 700,
+      top: 300,
+      right: 1100,
+      bottom: 700,
+      ring: true,
+    };
+    const frames = [0, 2, 4, 6, 8].map((time) =>
+      frame(time, { selector: "#spoke", ax: 180, ay: 160, bx: 900, by: 500 }, [peripheral, arc]),
+    );
+    expect(detectConnectorMotionDetached(frames, CANVAS)).toHaveLength(1);
+  });
+
   it("still fires when the loose end sits in a ring's hollow centre", () => {
     // End B at the ring centre 900,500 is ~200px from its perimeter → dangling.
     const frames = [0, 2, 4, 6, 8].map((time) =>

packages/cli/src/utils/checkPipeline.ts

@@ -756,6 +756,30 @@ function isDangling(gaps: EndpointHeldGaps): boolean {
   return gaps.detachedFraction >= CONNECTOR_HELD_DETACH_FRAC;
 }
 
+// Gauge-indicator geometry: the anchored end pivots near a ring/arc centre and
+// the loose end extends radially outward. That is a needle/pointer (owned by a
+// separate gauge check), not a broken node connector. A defective radial
+// connector points the other way — anchored on a peripheral node, loose end
+// drifting toward the centre — so this only excludes true centre-pivot pointers.
+const GAUGE_HUB_CENTRE_FRACTION = 0.25;
+
+function isGaugeIndicator(
+  anchored: { x: number; y: number },
+  dangling: { x: number; y: number },
+  nodes: ConnectorNodeBox[],
+): boolean {
+  for (const node of nodes) {
+    if (!node.ring) continue;
+    const cx = (node.left + node.right) / 2;
+    const cy = (node.top + node.bottom) / 2;
+    const size = Math.max(node.right - node.left, node.bottom - node.top);
+    const dAnchored = Math.hypot(anchored.x - cx, anchored.y - cy);
+    const dDangling = Math.hypot(dangling.x - cx, dangling.y - cy);
+    if (dAnchored <= GAUGE_HUB_CENTRE_FRACTION * size && dDangling > dAnchored) return true;
+  }
+  return false;
+}
+
 function connectorDetachFinding(
   selector: string,
   point: { x: number; y: number },
@@ -803,6 +827,49 @@ function connectorDetachFinding(
  * lines to a nearby label do not); and a selector that aliases multiple
  * connectors in one frame is dropped.
  */
+interface DanglePick {
+  anchored: { x: number; y: number };
+  dangling: { x: number; y: number };
+  gap: number;
+}
+
+/** If exactly one endpoint is anchored and the other persistently dangles, name
+ * the anchored/dangling points and the dangling gap; else null. */
+function danglingEndpoint(
+  last: ConnectorObservation,
+  gapsA: EndpointHeldGaps,
+  gapsB: EndpointHeldGaps,
+): DanglePick | null {
+  const a = { x: last.ax, y: last.ay };
+  const b = { x: last.bx, y: last.by };
+  if (isAnchored(gapsA) && isDangling(gapsB) && !isAnchored(gapsB)) {
+    return { anchored: a, dangling: b, gap: gapsB.danglingGap };
+  }
+  if (isAnchored(gapsB) && isDangling(gapsA) && !isAnchored(gapsA)) {
+    return { anchored: b, dangling: a, gap: gapsA.danglingGap };
+  }
+  return null;
+}
+
+/** One connector's held trajectory → a finding, or null. A finding needs one
+ * endpoint anchored to a node and the other persistently in empty space, and is
+ * suppressed for gauge-indicator geometry (see isGaugeIndicator). */
+function connectorGroupFinding(
+  selector: string,
+  group: ConnectorObservation[],
+  holdStart: number,
+  detachThreshold: number,
+): AnchoredLayoutIssue | null {
+  const last = group.length >= CONNECTOR_MIN_FRAMES ? group[group.length - 1] : undefined;
+  if (!last) return null;
+  const gapsA = endpointHeldGaps(group, (o) => ({ x: o.ax, y: o.ay }), holdStart, detachThreshold);
+  const gapsB = endpointHeldGaps(group, (o) => ({ x: o.bx, y: o.by }), holdStart, detachThreshold);
+  if (!gapsA || !gapsB) return null;
+  const pick = danglingEndpoint(last, gapsA, gapsB);
+  if (!pick || isGaugeIndicator(pick.anchored, pick.dangling, last.nodes)) return null;
+  return connectorDetachFinding(selector, pick.dangling, pick.gap, last.time);
+}
+
 export function detectConnectorMotionDetached(
   frames: ConnectorFrame[],
   canvas: Canvas,
@@ -816,24 +883,8 @@ export function detectConnectorMotionDetached(
     CONNECTOR_DETACH_VIEWPORT_FRACTION * Math.min(canvas.width, canvas.height),
   );
   for (const [selector, group] of groupConnectorsBySelector(frames)) {
-    if (group.length < CONNECTOR_MIN_FRAMES) continue;
-    const last = group[group.length - 1];
-    if (!last) continue;
-    const pickA = (o: ConnectorObservation) => ({ x: o.ax, y: o.ay });
-    const pickB = (o: ConnectorObservation) => ({ x: o.bx, y: o.by });
-    const gapsA = endpointHeldGaps(group, pickA, holdStart, detachThreshold);
-    const gapsB = endpointHeldGaps(group, pickB, holdStart, detachThreshold);
-    if (!gapsA || !gapsB) continue;
-    // One endpoint anchored to a node, the other persistently in empty space.
-    if (isAnchored(gapsA) && isDangling(gapsB) && !isAnchored(gapsB)) {
-      findings.push(
-        connectorDetachFinding(selector, { x: last.bx, y: last.by }, gapsB.danglingGap, last.time),
-      );
-    } else if (isAnchored(gapsB) && isDangling(gapsA) && !isAnchored(gapsA)) {
-      findings.push(
-        connectorDetachFinding(selector, { x: last.ax, y: last.ay }, gapsA.danglingGap, last.time),
-      );
-    }
+    const finding = connectorGroupFinding(selector, group, holdStart, detachThreshold);
+    if (finding) findings.push(finding);
   }
   return findings;
 }