diff --git a/packages/components/scripts/generate-chat-workspace-geometry-report.mjs b/packages/components/scripts/generate-chat-workspace-geometry-report.mjs
index e645f0954..5998134d7 100644
--- a/packages/components/scripts/generate-chat-workspace-geometry-report.mjs
+++ b/packages/components/scripts/generate-chat-workspace-geometry-report.mjs
@@ -3,6 +3,7 @@ import { spawn } from 'node:child_process';
 import { createServer } from 'node:net';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { MAX_REPORT_SCREENSHOTS } from './geometry-report-budget.mjs';
 
 const packageRoot = fileURLToPath(new URL('..', import.meta.url));
 const templatePath = path.join(
@@ -140,7 +141,6 @@ const detailImageBytes = imageStats.reduce((total, { file }) => total + file.siz
 // A screenshot budget, enforced rather than intended. Cards are chosen by how
 // much they deviate, so an unbounded report is one nobody opens: the run fails
 // instead of quietly growing.
-const MAX_REPORT_SCREENSHOTS = 80;
 const assetFiles = (await readdir(path.join(outputDirectory, 'assets'))).filter((name) =>
   name.endsWith('.png')
 );
diff --git a/packages/components/scripts/geometry-report-budget.mjs b/packages/components/scripts/geometry-report-budget.mjs
new file mode 100644
index 000000000..9deea821b
--- /dev/null
+++ b/packages/components/scripts/geometry-report-budget.mjs
@@ -0,0 +1,2 @@
+/** Exclusive limit, shared by screenshot selection and final artifact validation. */
+export const MAX_REPORT_SCREENSHOTS = 80;
diff --git a/packages/components/scripts/templates/chat-workspace-geometry-report.html b/packages/components/scripts/templates/chat-workspace-geometry-report.html
index 535557d8b..a132dfc94 100644
--- a/packages/components/scripts/templates/chat-workspace-geometry-report.html
+++ b/packages/components/scripts/templates/chat-workspace-geometry-report.html
@@ -434,6 +434,37 @@
         color: var(--text);
       }
 
+      .visual-candidates {
+        margin: 28px 0;
+      }
+      .visual-candidates details {
+        padding: 12px 0;
+        border-bottom: 1px solid var(--border);
+      }
+      .visual-candidates summary {
+        cursor: pointer;
+      }
+      .visual-candidates .evidence {
+        color: var(--text-muted);
+        font-size: 13px;
+        overflow-wrap: anywhere;
+      }
+      .visual-overlay {
+        position: relative;
+        margin-top: 12px;
+      }
+      .visual-overlay img {
+        display: block;
+        width: 100%;
+      }
+      .visual-overlay svg {
+        position: absolute;
+        inset: 0;
+        width: 100%;
+        height: 100%;
+        pointer-events: none;
+      }
+
       /* ---------- lightbox ---------- */
 
       dialog.lightbox {
@@ -559,6 +590,33 @@ <h2>明确排除</h2>
         </div>
       </details>
 
+      <section class="visual-candidates" aria-label="Visual repetition candidates">
+        <h2>Visual repetition candidates · 未分诊</h2>
+        <p class="meta" id="visual-summary"></p>
+        <label
+          >Capture
+          <select id="visual-capture-filter">
+            <option value="">全部</option>
+          </select></label
+        >
+        <label
+          >Evidence
+          <select id="visual-evidence-filter">
+            <option value="review">Review candidates · peer ≥ 2</option>
+            <option value="all">All raw deviations</option>
+          </select></label
+        >
+        <a href="visual-repetition.json">完整 discovery JSON</a>
+        <p class="meta">
+          排序仅供 review；不进入 ledger / gate。红框为候选，绿框为 dominant，橙框为
+          peers，绿线为预期坐标；pitch 是间距，仅标记目标。默认合并同一 atom 的重复边界测量；
+          完整原始结果见 JSON。
+        </p>
+        <div id="visual-candidates"></div>
+        <button type="button" id="visual-more">显示更多</button>
+      </section>
+
+      <h2>Existing rails</h2>
       <div class="toolbar" id="toolbar" role="group" aria-label="按类型筛选"></div>
 
       <div class="detail-reviews" id="detail-reviews"></div>
@@ -580,6 +638,160 @@ <h2>明确排除</h2>
     <script>
       const report = JSON.parse(document.getElementById('geometry-report-data').textContent);
 
+      const visualCaptures = report.visualRepetition?.captures ?? [];
+      const rawVisualCandidates = visualCaptures
+        .flatMap((capture) => {
+          const atoms = new Map(capture.atoms.map((atom) => [atom.id, atom]));
+          return capture.deviations.map((deviation) => ({
+            capture,
+            deviation,
+            atom: atoms.get(deviation.atomId),
+            atoms,
+          }));
+        })
+        .sort((a, b) => b.deviation.score - a.deviation.score);
+      const rankVisualCandidates = (candidates) =>
+        [...candidates]
+          .sort((a, b) => b.deviation.score - a.deviation.score)
+          .map((candidate, index) => ({ ...candidate, rank: index + 1 }));
+      const reviewVisualCandidates = rankVisualCandidates(
+        rawVisualCandidates
+          .filter(({ deviation }) => deviation.peerSupport >= 2)
+          .reduce((unique, candidate) => {
+            // Start/end/center are three views of one edge question. Keep pitch
+            // separate because it measures spacing along the series axis.
+            const { capture, deviation, atom } = candidate;
+            const measureFamily = deviation.measure === 'pitch' ? 'pitch' : 'edge';
+            const key = `${capture.captureId}\u0000${atom.id}\u0000${deviation.axis}\u0000${measureFamily}`;
+            const previous = unique.get(key);
+            if (!previous || previous.deviation.score < deviation.score) unique.set(key, candidate);
+            return unique;
+          }, new Map())
+          .values()
+      );
+      const visualCandidates = rankVisualCandidates(rawVisualCandidates);
+      document.getElementById('visual-summary').textContent =
+        `${visualCaptures.length} captures · ${visualCaptures.reduce((sum, capture) => sum + capture.atoms.length, 0)} atoms · ${reviewVisualCandidates.length} review candidates / ${visualCandidates.length} raw deviations · 每个 capture 独立计算，尚未跨 capture 确认`;
+      const visualList = document.getElementById('visual-candidates');
+      const px = (value) => `${Number(value.toFixed(2))}px`;
+      function appendVisualCandidate({ capture, deviation, atom, atoms, rank }) {
+        const card = document.createElement('details');
+        const heading = document.createElement('summary');
+        const signedDelta = deviation.value - deviation.expected;
+        heading.textContent = `#${rank} ${atom.label} · ${deviation.axis}-${deviation.measure} · ${signedDelta >= 0 ? '+' : ''}${px(signedDelta)} · ${capture.captureId}`;
+        card.append(heading);
+        // Materialize images only on expansion; retain every ranked candidate.
+        card.addEventListener('toggle', () => {
+          if (!card.open || card.dataset.rendered) return;
+          card.dataset.rendered = 'true';
+          const evidence = document.createElement('p');
+          evidence.className = 'evidence';
+          evidence.textContent = `expected ${px(deviation.expected)} · actual ${px(deviation.value)} · dominant support ${deviation.dominantSupport} · peer support ${deviation.peerSupport} · series ${deviation.seriesSize} · score ${Number(deviation.score.toFixed(2))} · ${deviation.signature}`;
+          const provenance = document.createElement('p');
+          provenance.className = 'evidence';
+          provenance.textContent = `${capture.captureId} · ${capture.viewport.width}×${capture.viewport.height} · DPR ${capture.deviceScaleFactor} · ${JSON.stringify(capture.dimensions ?? {})} · ${atom.id} · ${atom.scope ?? ''} · ${atom.component ?? ''} · ${atom.className ?? ''}`;
+          card.append(evidence, provenance);
+          const witnesses = document.createElement('p');
+          witnesses.className = 'evidence';
+          const labels = (ids) => ids.map((id) => `${atoms.get(id).label} (${id})`).join(' · ');
+          witnesses.textContent = `Dominant: ${labels(deviation.dominantAtomIds)} / Peers: ${labels(deviation.peerAtomIds)}`;
+          card.append(witnesses);
+          if (!capture.screenshot || !capture.screenshotClip) {
+            const missing = document.createElement('p');
+            missing.className = 'evidence';
+            missing.textContent = '此 capture 未保存整体截图；完整测量见 visual-repetition.json。';
+            card.append(missing);
+            return;
+          }
+          const clip = capture.screenshotClip;
+          const figure = document.createElement('div');
+          figure.className = 'visual-overlay';
+          const image = document.createElement('img');
+          image.src = capture.screenshot;
+          image.alt = `${capture.captureId} · ${atom.label}`;
+          const ns = 'http://www.w3.org/2000/svg';
+          const overlay = document.createElementNS(ns, 'svg');
+          overlay.setAttribute('viewBox', `${clip.x} ${clip.y} ${clip.width} ${clip.height}`);
+          const addBox = (member, color) => {
+            const box = document.createElementNS(ns, 'rect');
+            for (const [key, value] of Object.entries({
+              x: member.xStart,
+              y: member.yStart,
+              width: member.xEnd - member.xStart,
+              height: member.yEnd - member.yStart,
+              fill: 'none',
+              stroke: color,
+              'stroke-width': 2,
+            }))
+              box.setAttribute(key, String(value));
+            overlay.append(box);
+          };
+          deviation.dominantAtomIds.forEach((id) => addBox(atoms.get(id), '#10b981'));
+          deviation.peerAtomIds.forEach((id) => addBox(atoms.get(id), '#f59e0b'));
+          addBox(atom, '#ff4050');
+          if (deviation.measure !== 'pitch') {
+            const line = document.createElementNS(ns, 'line');
+            const points =
+              deviation.axis === 'x'
+                ? {
+                    x1: deviation.expected,
+                    x2: deviation.expected,
+                    y1: clip.y,
+                    y2: clip.y + clip.height,
+                  }
+                : {
+                    y1: deviation.expected,
+                    y2: deviation.expected,
+                    x1: clip.x,
+                    x2: clip.x + clip.width,
+                  };
+            for (const [key, value] of Object.entries({
+              ...points,
+              stroke: '#10b981',
+              'stroke-width': 1,
+              'stroke-dasharray': '4 3',
+            }))
+              line.setAttribute(key, String(value));
+            overlay.append(line);
+          }
+          figure.append(image, overlay);
+          card.append(figure);
+        });
+        visualList.append(card);
+      }
+      const captureFilter = document.getElementById('visual-capture-filter');
+      const evidenceFilter = document.getElementById('visual-evidence-filter');
+      for (const capture of visualCaptures) {
+        const option = document.createElement('option');
+        option.value = capture.captureId;
+        option.textContent = `${capture.captureId} (${capture.deviations.length})`;
+        captureFilter.append(option);
+      }
+      let selectedVisualCandidates = reviewVisualCandidates;
+      let visibleVisualCount = 0;
+      const visualMore = document.getElementById('visual-more');
+      function showMoreVisualCandidates() {
+        const next = selectedVisualCandidates.slice(visibleVisualCount, visibleVisualCount + 30);
+        next.forEach(appendVisualCandidate);
+        visibleVisualCount += next.length;
+        visualMore.hidden = visibleVisualCount === selectedVisualCandidates.length;
+        visualMore.textContent = `显示更多 (${visibleVisualCount}/${selectedVisualCandidates.length})`;
+      }
+      visualMore.addEventListener('click', showMoreVisualCandidates);
+      const updateVisualCandidates = () => {
+        const candidates =
+          evidenceFilter.value === 'all' ? visualCandidates : reviewVisualCandidates;
+        selectedVisualCandidates = candidates.filter(
+          ({ capture }) => !captureFilter.value || capture.captureId === captureFilter.value
+        );
+        visibleVisualCount = 0;
+        visualList.replaceChildren();
+        showMoreVisualCandidates();
+      };
+      captureFilter.addEventListener('change', updateVisualCandidates);
+      evidenceFilter.addEventListener('change', updateVisualCandidates);
+      showMoreVisualCandidates();
+
       const chevronSvg =
         '<svg class="chevron" viewBox="0 0 16 16" fill="none" aria-hidden="true">' +
         '<path d="M6 4l4 4-4 4" stroke="currentColor" stroke-width="1.5" ' +
diff --git a/packages/components/src/lib/geometry-discovery/AGENTS.md b/packages/components/src/lib/geometry-discovery/AGENTS.md
new file mode 100644
index 000000000..92261434b
--- /dev/null
+++ b/packages/components/src/lib/geometry-discovery/AGENTS.md
@@ -0,0 +1,56 @@
+# `components/src/lib/geometry-discovery` — heuristic layout discovery
+
+`CLAUDE.md` is a symlink to this file. Edit `AGENTS.md` only. Package
+[AGENTS.md](../../../AGENTS.md) and [src/lib/AGENTS.md](../AGENTS.md) apply.
+
+The authored path — `geometry-contracts.json`, its compiled contracts and the ratchet in
+[tests/e2e](../../../tests/e2e/AGENTS.md) — only finds what a reviewer already wrote down,
+and names its members by DOM shape. This directory is the other half: expectations are
+MINED from what the product repeatedly renders, and nobody writes the number down.
+
+`visual-capture.ts` projects each persisted capture's complete block-candidate rectangles
+into one atom per primitive, deduplicating anchors and overlapping scopes. Mine each capture
+independently; DOM ordinals are capture-local references, not durable finding identities.
+Labels, scopes and Fiber pointers are report evidence only and never grouping inputs.
+The report writes `visual-repetition.json` beside the existing rail artifacts and displays
+all ranked deviations as untriaged candidates, outside findings, ledger and gate.
+Screenshot overlays reuse the owning capture's clean overview and clip; a capture without
+an overview says so explicitly. Dominant/peer primitive references travel with the deviation
+as witnesses, never as finding keys.
+A recall-first pass that blocks CI has exactly one natural remedy, raising its thresholds,
+which destroys the recall it exists for.
+
+## Grouping is visual. Never structural.
+
+Atoms are grouped by what RENDERS alike — the geometry-derived primitive kind, folded where
+the difference is not painted (`link`/`button`, `numeric-text`/`text`), and quantised height,
+never content-sized width. Never key a group on row family, role, accessible name, or DOM
+ancestry.
+
+The reason is not purity. A layout defect almost always comes from two code paths rendering
+one visual thing differently — the sidebar's 26px tree indent slot and the mobile screen's
+32px one are separate constants in separate files. So the defect CORRELATES with the
+structural difference, and a structural key files the two paths into different groups and
+never compares them: the more real the bug, the more reliably it is hidden. The reader
+perceives a column because pixels line up, not because elements share a tag.
+
+`VisualAtom.id` names a primitive within one capture and must stay out of grouping. The
+moment identity decides who is compared with whom, that blindness is back.
+
+## Levels grow to an ANCHOR, not to a neighbour
+
+A coordinate joins a level by distance to the level's anchor. Single linkage would let a
+run of intermediate values walk one level into the next and merge two indentation depths
+into one expectation — the merged level then reads as internally perfect and the deviation
+disappears. Same failure the geometric row band avoids on Y.
+
+## Recall is the bias, and ranking is not filtering
+
+Nothing is dropped for looking weak. Candidates carry a `score` and are sorted; no
+threshold removes one. A legitimate indent ladder therefore comes back as deviations too,
+because without being told which level was intended it has to — it ranks low since `score`
+falls as a level's own support rises, so a value two boxes share outranks one forty share.
+
+A missed misalignment is invisible forever; a false one costs a triage glance. Any tie
+breaks towards reporting more. Series orientation is measured rather than declared, and
+only the axis perpendicular to the run carries expectations worth mining.
diff --git a/packages/components/src/lib/geometry-discovery/CLAUDE.md b/packages/components/src/lib/geometry-discovery/CLAUDE.md
new file mode 120000
index 000000000..47dc3e3d8
--- /dev/null
+++ b/packages/components/src/lib/geometry-discovery/CLAUDE.md
@@ -0,0 +1 @@
+AGENTS.md
\ No newline at end of file
diff --git a/packages/components/src/lib/geometry-discovery/visual-capture.ts b/packages/components/src/lib/geometry-discovery/visual-capture.ts
new file mode 100644
index 000000000..947f1db7d
--- /dev/null
+++ b/packages/components/src/lib/geometry-discovery/visual-capture.ts
@@ -0,0 +1,65 @@
+import type { GeometryCapture, GeometryCaptureArtifact } from '../geometry-constraint-system';
+import { mineVisualDeviations, type VisualAtom } from './visual-repetition';
+
+/**
+ * Project one capture, never a matrix: DOM ordinals and visual series are local
+ * to a page. Block candidates retain the complete measured primitive rectangle,
+ * including primitives outside rows; anchor coordinates are not box extents.
+ */
+export function projectVisualAtoms(capture: GeometryCapture): VisualAtom[] {
+  const atoms = new Map<string, VisualAtom>();
+  for (const scope of capture.scopes) {
+    for (const candidate of scope.blockCandidates ?? []) {
+      if (atoms.has(candidate.primitiveId)) continue;
+      atoms.set(candidate.primitiveId, {
+        id: candidate.primitiveId,
+        kind: candidate.kind ?? 'unknown',
+        xStart: candidate.xStart,
+        xEnd: candidate.xEnd,
+        yStart: candidate.yStart,
+        yEnd: candidate.yEnd,
+      });
+    }
+  }
+  return [...atoms.values()];
+}
+
+/** Discovery evidence only. No finding identity, ledger status or gate verdict. */
+export function discoverVisualRepetition(artifact: GeometryCaptureArtifact) {
+  return {
+    version: 1 as const,
+    captures: artifact.captures.map((capture) => {
+      const atoms = projectVisualAtoms(capture);
+      const evidence = new Map(
+        capture.scopes.flatMap((scope) =>
+          (scope.blockCandidates ?? []).map(
+            (candidate) => [candidate.primitiveId, candidate] as const
+          )
+        )
+      );
+      return {
+        captureId: capture.captureId,
+        surface: capture.surface,
+        storyId: capture.storyId,
+        viewport: capture.viewport,
+        deviceScaleFactor: capture.deviceScaleFactor,
+        dimensions: capture.dimensions,
+        screenshot: capture.screenshot,
+        atoms: atoms.map((atom) => {
+          const candidate = evidence.get(atom.id)!;
+          const node = candidate.boxModelNodeRef
+            ? capture.boxModelNodes?.[candidate.boxModelNodeRef]
+            : undefined;
+          return {
+            ...atom,
+            label: candidate.label,
+            scope: candidate.sectionScope,
+            component: node?.component,
+            className: node?.className,
+          };
+        }),
+        deviations: mineVisualDeviations(atoms),
+      };
+    }),
+  };
+}
diff --git a/packages/components/src/lib/geometry-discovery/visual-repetition.ts b/packages/components/src/lib/geometry-discovery/visual-repetition.ts
new file mode 100644
index 000000000..270ed8bc1
--- /dev/null
+++ b/packages/components/src/lib/geometry-discovery/visual-repetition.ts
@@ -0,0 +1,316 @@
+/**
+ * Heuristic discovery of layout deviations from visual repetition alone.
+ *
+ * The authored path (`geometry-contracts.json`) can only find what someone
+ * already wrote down, and it names its members by DOM shape — role, accessible
+ * name, row family. That is the wrong ground truth twice over. A layout bug
+ * almost always comes from two code paths rendering the same visual thing
+ * differently, so the defect CORRELATES with the DOM difference: grouping by
+ * DOM shape files the two paths into separate families and never compares
+ * them. And a reader perceives a column of avatars as a column because the
+ * pixels line up, not because the elements share a tag.
+ *
+ * So nothing here reads structure. Atoms are grouped by what they look like,
+ * a repeating series is whatever renders as a repeating series, and the
+ * expected coordinate is mined from what the majority of that series actually
+ * does. Nobody writes down that the indent step is 26px; it is counted.
+ *
+ * The bias is recall. A missed misalignment is invisible forever, while a
+ * false one costs a triage glance, so nothing is dropped for looking weak —
+ * candidates are ranked, not filtered, and every tie is broken towards
+ * reporting more.
+ */
+
+/**
+ * A rendered box. `id` references a primitive within its capture and never
+ * takes part in grouping: the moment identity decides who is compared with
+ * whom, the DOM blindness described above is back.
+ */
+export type VisualAtom = Readonly<{
+  id: string;
+  /** Geometry-derived primitive kind, never a semantic contract name. */
+  kind: string;
+  xStart: number;
+  xEnd: number;
+  yStart: number;
+  yEnd: number;
+}>;
+
+export type VisualDeviationMeasure = 'start' | 'end' | 'center' | 'pitch';
+
+export type VisualDeviation = Readonly<{
+  atomId: string;
+  /** The visual signature whose series this atom deviates inside. */
+  signature: string;
+  axis: 'x' | 'y';
+  measure: VisualDeviationMeasure;
+  value: number;
+  /** Median of the best-supported level in the same series. */
+  expected: number;
+  delta: number;
+  /** How many series members share this atom's value. */
+  peerSupport: number;
+  /** How many share the level it deviates from. */
+  dominantSupport: number;
+  /** Capture-local witnesses, retained so a report can show the actual comparison. */
+  dominantAtomIds: readonly string[];
+  peerAtomIds: readonly string[];
+  seriesSize: number;
+  /** Higher is more suspicious. Ranking only; never a pass/fail threshold. */
+  score: number;
+}>;
+
+export type VisualRepetitionOptions = Readonly<{
+  /**
+   * Shortest run that can carry an expectation at all. Two boxes agreeing is
+   * a coincidence; three is the weakest thing that can be called usual.
+   */
+  minimumSeriesLength?: number;
+  /**
+   * How far apart two coordinates may be and still count as the same level.
+   * Sits at measurement noise (1/devicePixelRatio of the coarsest capture),
+   * not at a design tolerance — a real indent step is an order of magnitude
+   * above it.
+   */
+  levelTolerance?: number;
+  /** Heights within this distance describe the same kind of box. */
+  heightTolerance?: number;
+  /**
+   * A gap this many times the series median ends the series. Purely visual
+   * locality: it separates two lists that happen to render alike, without
+   * severing a list that a date header interrupts.
+   */
+  seriesBreakRatio?: number;
+}>;
+
+const DEFAULTS = {
+  minimumSeriesLength: 3,
+  levelTolerance: 1,
+  heightTolerance: 1,
+  seriesBreakRatio: 3,
+} as const;
+
+function median(values: readonly number[]): number {
+  const sorted = [...values].sort((left, right) => left - right);
+  const middle = Math.floor(sorted.length / 2);
+  return sorted.length % 2 === 0 ? (sorted[middle - 1]! + sorted[middle]!) / 2 : sorted[middle]!;
+}
+
+/**
+ * `link` versus `button` is a tag difference and `numeric-text` versus `text`
+ * is a content difference; neither is visible. Folding them widens each group,
+ * which is the direction that finds more.
+ */
+function normalizeKind(kind: string): string {
+  if (kind === 'link') return 'button';
+  if (kind === 'numeric-text') return 'text';
+  return kind;
+}
+
+/**
+ * Width is left out on purpose. A row's label is as wide as its text, so
+ * keying on width would split one visual series into one group per string
+ * length and leave nothing to compare.
+ */
+function visualSignature(atom: VisualAtom, heightTolerance: number): string {
+  const height = atom.yEnd - atom.yStart;
+  const bucket = heightTolerance > 0 ? Math.round(height / heightTolerance) : height;
+  return `${normalizeKind(atom.kind)}|h${bucket}`;
+}
+
+type Level = { readonly values: number[]; readonly atoms: VisualAtom[]; anchor: number };
+
+/**
+ * Levels grow by distance to the level's anchor, never to its nearest member.
+ * Single linkage would let a chain of intermediate coordinates walk one level
+ * into the next and quietly merge two indentation depths into one expectation
+ * — the merged level then looks internally perfect and the deviation vanishes.
+ */
+function buildLevels(
+  entries: readonly { readonly atom: VisualAtom; readonly value: number }[],
+  tolerance: number
+): Level[] {
+  const levels: Level[] = [];
+  for (const entry of [...entries].sort((left, right) => left.value - right.value)) {
+    const existing = levels.find((level) => Math.abs(entry.value - level.anchor) <= tolerance);
+    if (existing) {
+      existing.values.push(entry.value);
+      existing.atoms.push(entry.atom);
+      continue;
+    }
+    levels.push({ values: [entry.value], atoms: [entry.atom], anchor: entry.value });
+  }
+  return levels;
+}
+
+/**
+ * Every member of every non-dominant level is reported. In a legitimate indent
+ * ladder that means the whole indented half comes back as deviations — which
+ * is the accepted cost of not knowing in advance which of the two levels was
+ * intended. They rank low because they have each other: score falls as a
+ * level's own support rises, so a value only two boxes share outranks one
+ * forty boxes share, and the stray middle row sorts above the ladder.
+ */
+function scoreLevels(
+  levels: readonly Level[],
+  seriesSize: number,
+  signature: string,
+  axis: 'x' | 'y',
+  measure: VisualDeviationMeasure,
+  levelTolerance: number
+): VisualDeviation[] {
+  if (levels.length < 2) return [];
+  const dominant = levels.reduce((best, level) =>
+    level.atoms.length > best.atoms.length ? level : best
+  );
+  const dominantSupport = dominant.atoms.length;
+  const expected = median(dominant.values);
+  const deviations: VisualDeviation[] = [];
+  for (const level of levels) {
+    if (level === dominant) continue;
+    const peerSupport = level.atoms.length;
+    for (const [index, atom] of level.atoms.entries()) {
+      const value = level.values[index]!;
+      const delta = Math.abs(value - expected);
+      if (delta <= levelTolerance) continue;
+      deviations.push({
+        atomId: atom.id,
+        signature,
+        axis,
+        measure,
+        value,
+        expected,
+        delta,
+        peerSupport,
+        dominantSupport,
+        dominantAtomIds: dominant.atoms.map((member) => member.id),
+        peerAtomIds: level.atoms.map((member) => member.id),
+        seriesSize,
+        score: (delta * dominantSupport) / peerSupport,
+      });
+    }
+  }
+  return deviations;
+}
+
+/**
+ * Splits one signature group into runs that read as a single series. Members
+ * are ordered along the series axis and cut where the gap jumps far past the
+ * run's own median gap.
+ */
+function splitIntoSeries(
+  atoms: readonly VisualAtom[],
+  axis: 'x' | 'y',
+  breakRatio: number,
+  minimumLength: number
+): VisualAtom[][] {
+  const center = (atom: VisualAtom) =>
+    axis === 'y' ? (atom.yStart + atom.yEnd) / 2 : (atom.xStart + atom.xEnd) / 2;
+  const ordered = [...atoms].sort((left, right) => center(left) - center(right));
+  const gaps: number[] = [];
+  for (let index = 1; index < ordered.length; index += 1) {
+    gaps.push(center(ordered[index]!) - center(ordered[index - 1]!));
+  }
+  if (gaps.length === 0) return [];
+  const typicalGap = median(gaps);
+  const series: VisualAtom[][] = [];
+  let current: VisualAtom[] = [ordered[0]!];
+  for (let index = 1; index < ordered.length; index += 1) {
+    const gap = gaps[index - 1]!;
+    if (typicalGap > 0 && gap > typicalGap * breakRatio) {
+      series.push(current);
+      current = [];
+    }
+    current.push(ordered[index]!);
+  }
+  series.push(current);
+  return series.filter((run) => run.length >= minimumLength);
+}
+
+/**
+ * Orientation is measured, not declared: whichever axis the boxes spread along
+ * is the series axis, and the expectations worth mining are the ones
+ * perpendicular to it. Mining the series axis itself would only rediscover
+ * that a list advances down the page.
+ */
+function seriesAxis(atoms: readonly VisualAtom[]): 'x' | 'y' {
+  const xs = atoms.map((atom) => (atom.xStart + atom.xEnd) / 2);
+  const ys = atoms.map((atom) => (atom.yStart + atom.yEnd) / 2);
+  const spread = (values: readonly number[]) => Math.max(...values) - Math.min(...values);
+  return spread(ys) >= spread(xs) ? 'y' : 'x';
+}
+
+export function mineVisualDeviations(
+  atoms: readonly VisualAtom[],
+  options: VisualRepetitionOptions = {}
+): readonly VisualDeviation[] {
+  const minimumSeriesLength = options.minimumSeriesLength ?? DEFAULTS.minimumSeriesLength;
+  const levelTolerance = options.levelTolerance ?? DEFAULTS.levelTolerance;
+  const heightTolerance = options.heightTolerance ?? DEFAULTS.heightTolerance;
+  const seriesBreakRatio = options.seriesBreakRatio ?? DEFAULTS.seriesBreakRatio;
+
+  const groups = new Map<string, VisualAtom[]>();
+  for (const atom of atoms) {
+    const signature = visualSignature(atom, heightTolerance);
+    const group = groups.get(signature);
+    if (group) group.push(atom);
+    else groups.set(signature, [atom]);
+  }
+
+  const deviations: VisualDeviation[] = [];
+  for (const [signature, group] of groups) {
+    if (group.length < minimumSeriesLength) continue;
+    const axis = seriesAxis(group);
+    for (const run of splitIntoSeries(group, axis, seriesBreakRatio, minimumSeriesLength)) {
+      const edges =
+        axis === 'y'
+          ? ([
+              ['x', 'start', (atom: VisualAtom) => atom.xStart],
+              ['x', 'end', (atom: VisualAtom) => atom.xEnd],
+              ['x', 'center', (atom: VisualAtom) => (atom.xStart + atom.xEnd) / 2],
+            ] as const)
+          : ([
+              ['y', 'start', (atom: VisualAtom) => atom.yStart],
+              ['y', 'end', (atom: VisualAtom) => atom.yEnd],
+              ['y', 'center', (atom: VisualAtom) => (atom.yStart + atom.yEnd) / 2],
+            ] as const);
+
+      for (const [edgeAxis, measure, read] of edges) {
+        const entries = run.map((atom) => ({ atom, value: read(atom) }));
+        deviations.push(
+          ...scoreLevels(
+            buildLevels(entries, levelTolerance),
+            run.length,
+            signature,
+            edgeAxis,
+            measure,
+            levelTolerance
+          )
+        );
+      }
+
+      // Irregular spacing is the same kind of defect seen along the series
+      // axis, and the series is already ordered, so it costs nothing to mine.
+      const along = (atom: VisualAtom) =>
+        axis === 'y' ? (atom.yStart + atom.yEnd) / 2 : (atom.xStart + atom.xEnd) / 2;
+      const pitchEntries = run.slice(1).map((atom, index) => ({
+        atom,
+        value: along(atom) - along(run[index]!),
+      }));
+      if (pitchEntries.length >= minimumSeriesLength) {
+        deviations.push(
+          ...scoreLevels(
+            buildLevels(pitchEntries, levelTolerance),
+            run.length,
+            signature,
+            axis,
+            'pitch',
+            levelTolerance
+          )
+        );
+      }
+    }
+  }
+
+  return deviations.sort((left, right) => right.score - left.score);
+}
diff --git a/packages/components/tests/e2e/chat-workspace-geometry-report.spec.ts b/packages/components/tests/e2e/chat-workspace-geometry-report.spec.ts
index fc40566b6..56567fd80 100644
--- a/packages/components/tests/e2e/chat-workspace-geometry-report.spec.ts
+++ b/packages/components/tests/e2e/chat-workspace-geometry-report.spec.ts
@@ -1,7 +1,9 @@
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { mkdir, readdir, readFile, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 
 import { test, type Browser, type BrowserContext, type Page } from '@playwright/test';
+import { discoverVisualRepetition } from '../../src/lib/geometry-discovery/visual-capture';
+import { MAX_REPORT_SCREENSHOTS } from '../../scripts/geometry-report-budget.mjs';
 
 import {
   CHAT_WORKSPACE_GEOMETRY_ANCHORS,
@@ -2049,6 +2051,12 @@ test('captures the visual geometry report', async ({ browser }) => {
   const persistedCapture = JSON.parse(
     await readFile(capturePath, 'utf8')
   ) as GeometryCaptureArtifact;
+  const visualRepetition = discoverVisualRepetition(persistedCapture);
+  await writeFile(
+    path.join(outputDirectory, 'visual-repetition.json'),
+    `${JSON.stringify(visualRepetition, null, 2)}\n`,
+    'utf8'
+  );
   const observationArtifact = observeGeometryCaptures(persistedCapture);
   await writeFile(observationPath, `${JSON.stringify(observationArtifact, null, 2)}\n`, 'utf8');
 
@@ -2129,6 +2137,14 @@ test('captures the visual geometry report', async ({ browser }) => {
       )
     )
     .map((proposal) => crossFamilyProposalCard(proposal));
+  const capturedImageCount = (await readdir(assetsDirectory)).filter((file) =>
+    file.endsWith('.png')
+  ).length;
+  // Overview/X coverage consumes the same budget; each extra Y card needs two images.
+  const yCardLimit = Math.max(
+    0,
+    Math.min(MAX_Y_FINDING_CARDS, Math.floor((MAX_REPORT_SCREENSHOTS - 1 - capturedImageCount) / 2))
+  );
   const yCards = [
     ...selectYFindingCards(persistedFindings.findings, MAX_Y_FINDING_CARDS, warmCaptureIds).map(
       (card) => ({ ...card, detailKind: 'candidate' as const, idPrefix: 'block' })
@@ -2144,7 +2160,7 @@ test('captures the visual geometry report', async ({ browser }) => {
         Math.abs(right.finding.offset) - Math.abs(left.finding.offset) ||
         left.finding.label.localeCompare(right.finding.label)
     )
-    .slice(0, MAX_Y_FINDING_CARDS);
+    .slice(0, yCardLimit);
   const yCardDetails: ReportDetail[] = [];
   const yCardsByCapture = new Map<string, Array<{ detail: ReportDetail; index: number }>>();
   for (const [index, { finding, evidence, detailKind, idPrefix }] of yCards.entries()) {
@@ -2463,6 +2479,15 @@ test('captures the visual geometry report', async ({ browser }) => {
 
   const reportData = {
     generatedAt: new Date().toISOString(),
+    visualRepetition: {
+      ...visualRepetition,
+      captures: visualRepetition.captures.map((capture) => ({
+        ...capture,
+        screenshotClip: detailsByCaptureId
+          .get(capture.captureId)
+          ?.find((detail) => detail.kind === 'overview')?.clip,
+      })),
+    },
     viewport,
     spec: CHAT_WORKSPACE_GEOMETRY_SPEC,
     snapshot: measurement.snapshot,
diff --git a/packages/components/tests/e2e/geometry-visual-capture.spec.ts b/packages/components/tests/e2e/geometry-visual-capture.spec.ts
new file mode 100644
index 000000000..53f61097a
--- /dev/null
+++ b/packages/components/tests/e2e/geometry-visual-capture.spec.ts
@@ -0,0 +1,63 @@
+import { expect, test } from '@playwright/test';
+
+import { discoverVisualRepetition } from '../../src/lib/geometry-discovery/visual-capture';
+import {
+  buildGeometryCapture,
+  GEOMETRY_REPRESENTATIVE_CAPTURE,
+  observeGeometryPlanEntry,
+} from './support/geometry-capture-plan';
+
+test('projects browser-measured primitives into visual discovery across DOM structures', async ({
+  page,
+}) => {
+  await page.setContent(`
+    <style>
+      body { margin: 0; }
+      .row { height: 48px; padding-left: 24px; }
+      .mark { display: block; width: 16px; height: 16px; background: black; }
+      .sr-only {
+        position: absolute;
+        width: 1px;
+        height: 1px;
+        padding: 0;
+        margin: -1px;
+        overflow: hidden;
+        clip: rect(0, 0, 0, 0);
+        white-space: nowrap;
+        border: 0;
+      }
+    </style>
+    <main data-geometry-discovery-scope="fixture">
+      <span class="sr-only">Accessible label</span>
+      <div class="row"><span class="mark"></span></div>
+      <div class="row"><span class="mark"></span></div>
+      <div class="row"><span class="mark"></span></div>
+      <section class="row" style="padding-left:28px"><i class="mark"></i></section>
+      <div class="row"><span class="mark"></span></div>
+    </main>
+  `);
+  const observation = await observeGeometryPlanEntry(page, {
+    ...GEOMETRY_REPRESENTATIVE_CAPTURE,
+    captureId: 'synthetic-browser',
+    semanticObservations: false,
+  });
+  const artifact = JSON.parse(
+    JSON.stringify({ version: 1, captures: [buildGeometryCapture(observation)] })
+  );
+  const result = discoverVisualRepetition(artifact).captures[0]!;
+  expect(result.atoms.map((atom) => atom.label)).not.toContain('Accessible label');
+  const shifted = result.atoms.find((atom) => atom.kind === 'shape' && atom.xStart === 28);
+  expect(shifted).toBeDefined();
+  expect(
+    result.deviations.find(
+      (deviation) =>
+        deviation.atomId === shifted!.id && deviation.axis === 'x' && deviation.measure === 'start'
+    )
+  ).toMatchObject({
+    expected: 24,
+    value: 28,
+    delta: 4,
+    dominantSupport: 4,
+    peerSupport: 1,
+  });
+});
diff --git a/packages/components/tests/e2e/support/AGENTS.md b/packages/components/tests/e2e/support/AGENTS.md
index 95d190b68..9a539fb8d 100644
--- a/packages/components/tests/e2e/support/AGENTS.md
+++ b/packages/components/tests/e2e/support/AGENTS.md
@@ -20,6 +20,10 @@ the overlay and capture cannot disagree about one row.
   observation, never an ink one. A `<textarea>` is a FIELD before it is text: its default
   value is a child text node that never renders, and measuring it as text would make its
   48px box the ink of a label.
+- Visual primitives exclude CSS-clipped content (`clip` or `clip-path`), including
+  `sr-only`: it stays in the accessibility tree and its text range can still report
+  the full label bounds even though no pixels are painted. `aria-hidden` alone does
+  not exclude a visible decorative primitive from visual discovery.
 - Flow text gives start/end edges, never a centre; centred text only its centre; numeric
   text, diff statistics included, is trailing-edge.
 - Vertical anchors come from that same rect, so an SVG's box centre already IS its
diff --git a/packages/components/tests/e2e/support/chat-workspace-geometry.ts b/packages/components/tests/e2e/support/chat-workspace-geometry.ts
index 11c7ac06f..bb5319a85 100644
--- a/packages/components/tests/e2e/support/chat-workspace-geometry.ts
+++ b/packages/components/tests/e2e/support/chat-workspace-geometry.ts
@@ -712,6 +712,11 @@ export async function captureChatWorkspaceGeometryScopes(
         return (
           style.display !== 'none' &&
           style.visibility !== 'hidden' &&
+          // `sr-only` deliberately stays in the accessibility tree. Its
+          // clipped text range can still report the full label width, so a
+          // non-zero rect alone is not evidence that the primitive is painted.
+          (style.clip === 'auto' || style.clip === '') &&
+          style.clipPath === 'none' &&
           rect.right >= 0 &&
           rect.bottom >= 0 &&
           rect.left <= innerWidth &&
diff --git a/packages/components/tests/geometry-discovery-visual-capture.test.ts b/packages/components/tests/geometry-discovery-visual-capture.test.ts
new file mode 100644
index 000000000..29697ca84
--- /dev/null
+++ b/packages/components/tests/geometry-discovery-visual-capture.test.ts
@@ -0,0 +1,104 @@
+import { describe, expect, it } from 'vitest';
+
+import type {
+  GeometryCapture,
+  GeometryCapturedBlockCandidate,
+} from '../src/lib/geometry-constraint-system';
+import {
+  createGeometryFindings,
+  observeGeometryCaptures,
+} from '../src/lib/geometry-constraint-system';
+import {
+  discoverVisualRepetition,
+  projectVisualAtoms,
+} from '../src/lib/geometry-discovery/visual-capture';
+
+function capture(captureId: string, lefts: number[]): GeometryCapture {
+  const blockCandidates = lefts.flatMap((left, index) =>
+    (['block-start', 'block-center', 'visual-center', 'block-end'] as const).map(
+      (anchor): GeometryCapturedBlockCandidate => ({
+        primitiveId: `dom-${index}`,
+        elementId: `element-${index}`,
+        label: `Label ${index}`,
+        locator: { role: index === 3 ? 'link' : 'button' },
+        rowId: `row-${index}`,
+        rowFamily: index === 3 ? 'different-structure' : 'usual-structure',
+        kind: 'image',
+        space: 'ink',
+        anchor,
+        coordinate: 100 + index * 80 + (anchor === 'block-end' ? 24 : 0),
+        xStart: left,
+        xEnd: left + 24,
+        yStart: 100 + index * 80,
+        yEnd: 124 + index * 80,
+      })
+    )
+  );
+  const scope = {
+    key: 'scope',
+    identity: 'scope',
+    source: 'auto' as const,
+    depth: 1,
+    rect: { x: 0, y: 0, width: 500, height: 800 },
+    candidates: [],
+    blockCandidates,
+  };
+  return {
+    captureId,
+    surfaceFamily: 'workspace',
+    surface: 'fixture',
+    storyId: 'synthetic',
+    viewport: { width: 500, height: 800 },
+    deviceScaleFactor: 2,
+    screenshot: '',
+    scopes: [scope, { ...scope, key: 'parent', depth: 0 }],
+  };
+}
+
+describe('visual capture discovery', () => {
+  it('counts primitives once across anchors and scopes, preserving measured rectangles', () => {
+    const input = capture('one', [24, 24, 24, 28, 24]);
+    const atoms = projectVisualAtoms(input);
+    expect(atoms).toHaveLength(5);
+    expect(atoms[3]).toEqual({
+      id: 'dom-3',
+      kind: 'image',
+      xStart: 28,
+      xEnd: 52,
+      yStart: 340,
+      yEnd: 364,
+    });
+    const result = discoverVisualRepetition({ version: 1, captures: [input] });
+    expect(result.captures[0]!.deviations.find((item) => item.measure === 'start')).toMatchObject({
+      atomId: 'dom-3',
+      expected: 24,
+      value: 28,
+      dominantSupport: 4,
+      peerSupport: 1,
+      dominantAtomIds: ['dom-0', 'dom-1', 'dom-2', 'dom-4'],
+      peerAtomIds: ['dom-3'],
+      seriesSize: 5,
+    });
+  });
+
+  it('keeps reused DOM ids and coordinate expectations local to each capture', () => {
+    const result = discoverVisualRepetition({
+      version: 1,
+      captures: [
+        capture('light', [24, 24, 24, 28, 24]),
+        capture('dark', [100, 100, 100, 100, 100]),
+      ],
+    });
+    expect(result.captures[0]!.deviations.length).toBeGreaterThan(0);
+    expect(result.captures[1]!.deviations).toEqual([]);
+  });
+
+  it('keeps untriaged visual candidates outside the finding output', () => {
+    const input = { version: 1 as const, captures: [capture('one', [24, 24, 24, 28, 24])] };
+    const original = structuredClone(input);
+    const visual = discoverVisualRepetition(input);
+    expect(visual.captures[0]!.deviations.length).toBeGreaterThan(0);
+    expect(input).toEqual(original);
+    expect(createGeometryFindings(input, observeGeometryCaptures(input)).findings).toEqual([]);
+  });
+});
diff --git a/packages/components/tests/geometry-discovery-visual-repetition.test.ts b/packages/components/tests/geometry-discovery-visual-repetition.test.ts
new file mode 100644
index 000000000..34e897998
--- /dev/null
+++ b/packages/components/tests/geometry-discovery-visual-repetition.test.ts
@@ -0,0 +1,118 @@
+import { describe, expect, it } from 'vitest';
+
+import {
+  mineVisualDeviations,
+  type VisualAtom,
+} from '../src/lib/geometry-discovery/visual-repetition';
+
+/**
+ * Rows of one visual kind stacked at a fixed pitch, each placed at the left
+ * edge the caller asks for. Fixtures are synthetic coordinates only; nothing
+ * here reads a real capture.
+ */
+function stackedRows(
+  lefts: readonly number[],
+  options?: { kinds?: readonly string[] }
+): VisualAtom[] {
+  return lefts.map((left, index) => ({
+    id: `row-${index}`,
+    kind: options?.kinds?.[index] ?? 'image',
+    xStart: left,
+    xEnd: left + 24,
+    yStart: 100 + index * 80,
+    yEnd: 124 + index * 80,
+  }));
+}
+
+function leftEdgeDeviations(atoms: readonly VisualAtom[]) {
+  return mineVisualDeviations(atoms).filter(
+    (deviation) => deviation.axis === 'x' && deviation.measure === 'start'
+  );
+}
+
+describe('mineVisualDeviations', () => {
+  it('reports the rows a series leaves off its own left edge', () => {
+    // The reported shape: the run starts and ends on one edge and a block in
+    // the middle sits elsewhere. Nothing declares which edge is correct; the
+    // better-supported one wins by count.
+    const atoms = stackedRows([100, 100, 100, 143, 143, 143, 143, 100, 100, 100]);
+
+    const deviations = leftEdgeDeviations(atoms);
+
+    expect(deviations.map((deviation) => deviation.atomId).sort()).toEqual([
+      'row-3',
+      'row-4',
+      'row-5',
+      'row-6',
+    ]);
+    expect(deviations[0]).toMatchObject({ expected: 100, value: 143, delta: 43 });
+  });
+
+  it('stays silent on a series that agrees with itself', () => {
+    expect(leftEdgeDeviations(stackedRows([100, 100, 100, 100, 100, 100]))).toEqual([]);
+  });
+
+  it('does not let intermediate coordinates chain two edges into one level', () => {
+    // Single linkage would walk 100 through to 126 one step at a time and call
+    // the whole run a single edge, which is exactly how a real indentation
+    // difference disappears. Levels grow by distance to their anchor instead.
+    const atoms = stackedRows([100, 101, 102, 103, 104, 105, 106, 126]);
+
+    const deviations = leftEdgeDeviations(atoms);
+
+    expect(deviations.length).toBeGreaterThan(0);
+    expect(deviations.map((deviation) => deviation.atomId)).toContain('row-7');
+  });
+
+  it('compares boxes that differ only by tag, because that difference is not visible', () => {
+    // `link` and `button` are the same painted box. Splitting on them would
+    // file two code paths into separate groups and never compare them — the
+    // blindness this whole pass exists to remove.
+    const atoms = stackedRows([100, 100, 100, 100, 137], {
+      kinds: ['button', 'link', 'button', 'link', 'link'],
+    });
+
+    expect(leftEdgeDeviations(atoms).map((deviation) => deviation.atomId)).toEqual(['row-4']);
+  });
+
+  it('does not compare two lists that merely render alike', () => {
+    // Each list agrees with itself at its own left edge. The gap between them
+    // is far past the pitch inside either, so they are two series and neither
+    // becomes evidence about the other.
+    const first = stackedRows([100, 100, 100, 100]);
+    const second = stackedRows([300, 300, 300, 300]).map((atom, index) => ({
+      ...atom,
+      id: `second-${index}`,
+      yStart: atom.yStart + 900,
+      yEnd: atom.yEnd + 900,
+    }));
+
+    expect(leftEdgeDeviations([...first, ...second])).toEqual([]);
+  });
+
+  it('ranks a value few boxes share above one many share', () => {
+    // An indent ladder comes back as deviations too — without being told which
+    // level was intended, it has to. It sorts below the stray because a level
+    // with company is less suspicious than a level without.
+    const atoms = stackedRows([100, 100, 100, 100, 100, 100, 100, 100, 112, 126, 126, 126]);
+
+    const deviations = leftEdgeDeviations(atoms);
+
+    expect(deviations[0]?.atomId).toBe('row-8');
+    expect(deviations[0]?.peerSupport).toBe(1);
+  });
+
+  it('mines irregular spacing along the series axis', () => {
+    const atoms = stackedRows([100, 100, 100, 100, 100, 100]);
+    const shifted = atoms.map((atom, index) =>
+      index >= 3 ? { ...atom, yStart: atom.yStart + 31, yEnd: atom.yEnd + 31 } : atom
+    );
+
+    const pitch = mineVisualDeviations(shifted).filter(
+      (deviation) => deviation.measure === 'pitch'
+    );
+
+    expect(pitch.map((deviation) => deviation.atomId)).toEqual(['row-3']);
+    expect(pitch[0]).toMatchObject({ expected: 80, value: 111 });
+  });
+});