@nebulacomponents/citable 1.15.1 → 1.17.0

package/src/detectors/cwv.js

@@ -11,7 +11,7 @@
  * - CLS (Cumulative Layout Shift): < 0.1 good, < 0.25 needs improvement
  */
 
-import { defineDetector } from './framework.js';
+import { defineDetector, indexTargets, pageSubject } from './framework.js';
 
 /**
  * CWV-001: LCP element identified and optimized
@@ -164,8 +164,45 @@ export const CWV_003 = defineDetector({
   },
 });
 
+export const CWV_004 = defineDetector({
+  id: 'CWV-004',
+  name: 'Excessive DOM size and depth',
+  namespace: 'CWV',
+  discipline: ['seo'],
+  severity: 'medium',
+  deterministic: true,
+  requires: ['site'],
+  description: 'Page DOM tree exceeds 1,500 nodes or maximum nesting depth exceeds 32 levels, causing mobile crawler execution delays and Interaction to Next Paint (INP) degradation.',
+  remediation: 'Simplify DOM structure, paginate or virtualize repeated elements, and reduce deep nesting of wrapper containers.',
+  verification: 'Re-audit page to verify total DOM node count is <= 1,500 and maximum depth is <= 32.',
+  check: (ctx) => {
+    const hits = [];
+    const targets = ctx.site ? indexTargets(ctx) : ctx.page ? [ctx.page] : [];
+    for (const p of targets) {
+      if (p.status !== 200) continue;
+      const nodeCount = p.domNodeCount || 0;
+      const maxDepth = p.maxDomDepth || 0;
+      if (nodeCount > 1500 || maxDepth > 32) {
+        hits.push({
+          subject: pageSubject(p),
+          summary: `Excessive DOM complexity (${nodeCount > 1500 ? `${nodeCount} nodes` : ''}${nodeCount > 1500 && maxDepth > 32 ? ', ' : ''}${maxDepth > 32 ? `depth ${maxDepth}` : ''}) risks crawler execution timeout and INP latency`,
+          evidence: [
+            `total DOM nodes: ${nodeCount}`,
+            `maximum DOM depth: ${maxDepth}`,
+            'Google Lighthouse and mobile crawler guidelines recommend <= 1,500 nodes and <= 32 nesting levels',
+          ],
+          captured: { nodeCount, maxDepth },
+          expected: 'nodeCount <= 1500 and maxDepth <= 32',
+        });
+      }
+    }
+    return hits;
+  },
+});
+
 export const cwvDetectors = [
   CWV_001,
   CWV_002,
   CWV_003,
+  CWV_004,
 ];

package/src/detectors/evd.js

@@ -1,3 +1,5 @@
+import fs from 'node:fs';
+import path from 'node:path';
 import { defineDetector, entrySubject } from './framework.js';
 import { isPastDate } from '../shared/io.js';
 
@@ -161,4 +163,103 @@ D.push(defineDetector({
   },
 }));
 
+D.push(defineDetector({
+  id: 'EVD-008', name: 'Dangling media reference in claim evidence', namespace: 'EVD',
+  description: 'Claim evidence references a media asset (image, chart, diagram, or video) whose referenced source location or file is missing, unresolved, or unreachable.',
+  discipline: ['aeo', 'geo'], severity: 'high', deterministic: true, requires: ['registries'],
+  impact: { legal: 'medium', citation: 'medium' },
+  applicable_requirement: 'Registry §6.5 evidence sources; premise 3.5: verified evidence must be grounded and inspectable',
+  remediation: 'Ensure referenced media artifacts exist at the specified target path or update the source location with an accessible asset.',
+  verification: 'All media evidence sources resolve to valid accessible files or active URLs.',
+  check(ctx) {
+    const isMedia = (e) => {
+      const st = (e.source_type || '').toLowerCase();
+      if (['media', 'image', 'video', 'diagram', 'chart', 'screenshot'].includes(st)) return true;
+      if (typeof e.source === 'string' && /\.(png|jpe?g|svg|webp|gif|mp4|webm)$/i.test(e.source.split('?')[0].split('#')[0])) return true;
+      return false;
+    };
+
+    const hits = [];
+    for (const e of (ctx.registries?.evidence?.entries || [])) {
+      if (!isMedia(e)) continue;
+
+      let dangling = false;
+      let reason = '';
+
+      if (!e.source || e.source.trim() === '') {
+        dangling = true;
+        reason = 'source field is empty or missing';
+      } else if (!/^https?:\/\//i.test(e.source)) {
+        // Local file reference
+        const cleanPath = e.source.replace(/^\/+/, '');
+        let fileFound = false;
+
+        if (ctx.site?.dir) {
+          const fullPath = path.resolve(ctx.site.dir, cleanPath);
+          if (fs.existsSync(fullPath)) fileFound = true;
+        }
+        if (!fileFound && ctx.root) {
+          const fullPath = path.resolve(ctx.root, cleanPath);
+          if (fs.existsSync(fullPath)) fileFound = true;
+        }
+        if (!fileFound && ctx.site?.pages) {
+          fileFound = ctx.site.pages.some((p) =>
+            p.images?.some((img) => img.src === e.source || img.src === `/${cleanPath}` || img.src?.endsWith(cleanPath))
+          );
+        }
+
+        if (!fileFound) {
+          dangling = true;
+          reason = `local media file not found: ${cleanPath}`;
+        }
+      }
+
+      if (dangling) {
+        hits.push({
+          subject: entrySubject('evidence', e.evidence_id),
+          summary: `Evidence "${e.title}" references dangling or missing media (${reason})`,
+          evidence: [`source: ${e.source || '(missing)'}`, `source_type: ${e.source_type || 'unspecified'}`, `reason: ${reason}`],
+        });
+      }
+    }
+    return hits;
+  },
+}));
+
+D.push(defineDetector({
+  id: 'EVD-009', name: 'Unanchored PDF claim citation', namespace: 'EVD',
+  description: 'Evidence backed by a PDF document lacks a specific page, fragment, or section anchor (#page=, section, or page number in methodology/test_conditions), leaving cited claims unanchored and unfalsifiable.',
+  discipline: ['aeo', 'geo'], severity: 'low', deterministic: true, requires: ['registries'],
+  impact: { citation: 'medium', legal: 'low' },
+  applicable_requirement: 'AEO §8 version evidence; premise 3.5 precise citation anchoring for defensible claims',
+  false_positive_conditions: ['single-page PDF documents where page anchor is redundant'],
+  remediation: 'Append #page=<n> or specify the page/section citation in methodology or test_conditions.',
+  verification: 'PDF evidence sources carry explicit page, section, or fragment anchors.',
+  check(ctx) {
+    const isPdf = (e) => (e.source_type || '').toLowerCase() === 'pdf' || (typeof e.source === 'string' && /\.pdf([?#]|$)/i.test(e.source));
+    const hits = [];
+
+    for (const e of (ctx.registries?.evidence?.entries || [])) {
+      if (!isPdf(e)) continue;
+
+      const hasUrlAnchor = typeof e.source === 'string' && (/#page=\d+|#section|#[a-zA-Z0-9_-]{2,}/i.test(e.source));
+      const text = `${e.methodology || ''} ${e.test_conditions || ''}`;
+      const hasTextAnchor = /\b(page|p\.|section|sec\.|paragraph|para\.)\s*\d+/i.test(text);
+
+      if (!hasUrlAnchor && !hasTextAnchor) {
+        hits.push({
+          subject: entrySubject('evidence', e.evidence_id),
+          summary: `PDF evidence "${e.title}" lacks a specific page or section anchor for citation grounding`,
+          evidence: [
+            `source: ${e.source || '(missing)'}`,
+            `methodology: ${e.methodology || 'missing'}`,
+            `test_conditions: ${e.test_conditions || 'missing'}`,
+          ],
+        });
+      }
+    }
+    return hits;
+  },
+}));
+
 export default D;

package/src/detectors/framework.js

@@ -1,14 +1,20 @@
 import { sha256 } from '../shared/io.js';
+import { fileURLToPath } from 'node:url';
+import { readJson } from '../shared/io.js';
+
+const TOOL_VERSION = readJson(new URL('../../package.json', import.meta.url)).version;
 
 const REQUIRED = ['id', 'name', 'namespace', 'description', 'discipline', 'severity', 'deterministic', 'remediation', 'verification', 'check'];
 // RENDER (browser-rendered truth / source-render divergence) is reserved for the
 // rendered-truth phase; no RENDER detectors ship until a real renderer backs them.
-const NAMESPACES = ['TECH', 'CRAWL', 'ARCH', 'PAGE', 'ANS', 'ENTITY', 'CLAIM', 'EVD', 'SCHEMA', 'LINK', 'EXT', 'GEO', 'RECO', 'LIFE', 'MEAS', 'RENDER', 'HREFLANG', 'CWV', 'AGENT'];
+const NAMESPACES = ['TECH', 'CRAWL', 'ARCH', 'PAGE', 'ANS', 'ENTITY', 'CLAIM', 'EVD', 'SCHEMA', 'LINK', 'EXT', 'GEO', 'RECO', 'LIFE', 'MEAS', 'RENDER', 'HREFLANG', 'CWV', 'AGENT', 'CRO'];
 
 /**
  * Detector definition contract. `check(ctx)` returns raw hits:
- *   { subject: {type, identifier, url?, source_file?, source_location?}, summary, evidence: [..],
+ *   { subject: {type, identifier, url?, source_file?, source_location?, rendered_selector?}, summary, evidence: [..],
  *     captured?, expected?, severity?, confidence? }
+ * Bump `version` whenever detector logic, thresholds, or output semantics
+ * change; findings record it in provenance.detector_version.
  */
 export function defineDetector(def) {
   for (const k of REQUIRED) {
@@ -17,6 +23,7 @@ export function defineDetector(def) {
   if (!NAMESPACES.includes(def.namespace)) throw new Error(`detector ${def.id}: unknown namespace ${def.namespace}`);
   if (!def.id.startsWith(def.namespace + '-')) throw new Error(`detector id ${def.id} must be prefixed with namespace`);
   return {
+    version: 1,
     confidence_model: def.deterministic ? 'binary condition; confirmed when observed' : 'heuristic; confidence reported per finding',
     confidence: def.deterministic ? 'confirmed' : 'medium',
     finding_type: def.deterministic ? 'deterministic_observation' : 'probabilistic_inference',
@@ -28,6 +35,14 @@ export function defineDetector(def) {
   };
 }
 
+function evidenceSourceFor(detector, ctx) {
+  if (ctx.observations?.length && detector.requires?.includes('observations')) return 'controlled_observation';
+  if (detector.requires?.includes('registries') && detector.requires?.includes('site')) return 'registry+dom_parse';
+  if (detector.requires?.includes('registries')) return 'registry';
+  if (detector.requires?.includes('site')) return 'dom_parse';
+  return 'configuration';
+}
+
 /** Run detectors over a context; returns { findings, detectorsRun, detectorsSkipped, errors }. */
 export function runDetectors(detectors, ctx) {
   const findings = [];
@@ -53,6 +68,7 @@ export function runDetectors(detectors, ctx) {
       findings.push({
         finding_id: `F-${sha256(idSeed).slice(0, 12)}`,
         detector_id: d.id,
+        detector_name: d.name,
         run_id: ctx.runId ?? 'adhoc',
         timestamp: ts,
         discipline: d.discipline,
@@ -88,6 +104,20 @@ export function runDetectors(detectors, ctx) {
           expected_result: 'detector no longer reports this subject',
           detector_to_rerun: d.id,
         },
+        provenance: {
+          detector_version: d.version ?? 1,
+          tool_version: TOOL_VERSION,
+          source_url: hit.subject?.url ?? hit.subject?.identifier ?? null,
+          source_file: hit.subject?.source_file ?? null,
+          evidence_selector: hit.subject?.rendered_selector ?? hit.subject?.source_location ?? null,
+          evidence_source: evidenceSourceFor(d, ctx),
+          viewport: ctx.viewport ?? null,
+          viewport_note: ctx.viewport ? null : 'viewport not captured for this collection method; static source/built-output check',
+          methodology: d.deterministic
+            ? 'deterministic condition check over captured evidence'
+            : 'heuristic judgment; human semantic review required before acting',
+          revalidation_required: d.deterministic ? 'on_next_audit' : 'human_review_before_action',
+        },
         status: { state: 'open', first_seen: ts, last_seen: ts, resolved_at: null },
       });
     }

package/src/detectors/geoReco.js

@@ -1,5 +1,6 @@
 import { defineDetector, indexTargets, registryPageFor, sitePageFor, pageSubject, entrySubject } from './framework.js';
 import { classifyAnswerStance } from '../observations/stance.js';
+import { evaluateAnswerAttribution } from '../observations/attribution.js';
 
 const D = [];
 
@@ -324,6 +325,413 @@ D.push(defineDetector({
   },
 }));
 
+D.push(defineDetector({
+  id: 'GEO-008', name: 'Generative citation attributes unverified or distorted claim to brand', namespace: 'GEO',
+  description: 'Recorded generative engine answers attribute contradicted, distorted, or unverified factual claims to a registered entity or brand.',
+  discipline: ['geo', 'aeo'], severity: 'high', deterministic: false, requires: ['registries'],
+  finding_type: 'evidence_backed_semantic_finding',
+  impact: { representation: 'high', reputational: 'high', conversion: 'medium' },
+  applicable_requirement: 'GEO §6: accurate synthesis and entity representation; Rubric: narrative accuracy (§4 & §5) and claim boundedness (§1)',
+  false_positive_conditions: ['Answer accurately reflects a verified change in product capability not yet updated in registries'],
+  remediation: 'Review the generative engine answer against the narrative-accuracy and claim-boundedness rubrics, identify the distorted or unverified claim attribution, and update public corroborating evidence or submit engine correction requests.',
+  unsafe_shortcuts: ['deleting legitimate claim records to hide discrepancies', 'crawler prompt injection (GEO-001)'],
+  verification: 'Follow-up generative engine observations demonstrate accurate claim attribution without distorted or hallucinated assertions.',
+  review_required: true,
+  check(ctx) {
+    const entities = (ctx.registries?.entities?.entries || []).filter((e) => e.status !== 'retired');
+    if (!entities.length) return [];
+    const claims = (ctx.registries?.claims?.entries || []).filter((c) => c.status !== 'retired');
+    const hits = [];
+
+    // 1. Check observations (attribution or citation)
+    for (const obs of ctx.observations || []) {
+      if (obs.kind === 'attribution' && obs.data?.has_distorted_claims) {
+        for (const evalItem of obs.data.evaluations || []) {
+          if (evalItem.attribution_status === 'distorted') {
+            hits.push({
+              subject: entrySubject('claims', evalItem.claim_id),
+              summary: `Generative engine ${obs.data.engine || 'unknown'} attributes distorted claim "${evalItem.claim_id}" to entity "${obs.data.canonical_name}"`,
+              evidence: [
+                `engine: ${obs.data.engine || 'unknown'}`,
+                `prompt: ${obs.data.prompt_text || obs.data.prompt_id || 'unknown'}`,
+                `claim_id: ${evalItem.claim_id}`,
+                `claim_text: "${evalItem.claim_text}"`,
+                `assertion_excerpt: "${evalItem.assertion_excerpt}"`,
+                `reasons: ${(evalItem.reasons || []).join('; ')}`,
+                `reviewer: ${obs.data.reviewer || 'unreviewed (semantic review required)'}`,
+              ],
+              confidence: obs.data.reviewer ? 'confirmed' : 'medium',
+              finding_type: 'evidence_backed_semantic_finding',
+            });
+          }
+        }
+      } else if (obs.kind === 'citation' && obs.data?.answer_text) {
+        for (const e of entities) {
+          const evalRes = evaluateAnswerAttribution(obs.data.answer_text, e, { claims });
+          if (evalRes.mentioned && evalRes.has_distorted_claims) {
+            for (const evalItem of evalRes.evaluations) {
+              if (evalItem.attribution_status === 'distorted') {
+                hits.push({
+                  subject: entrySubject('claims', evalItem.claim_id),
+                  summary: `Generative engine ${obs.data.provider || 'unknown'} attributes distorted claim "${evalItem.claim_id}" to entity "${e.canonical_name}"`,
+                  evidence: [
+                    `engine: ${obs.data.provider || 'unknown'}`,
+                    `prompt: ${obs.data.prompt_text || obs.data.prompt_id || 'unknown'}`,
+                    `claim_id: ${evalItem.claim_id}`,
+                    `assertion_excerpt: "${evalItem.assertion_excerpt}"`,
+                    `reasons: ${(evalItem.reasons || []).join('; ')}`,
+                  ],
+                  confidence: 'medium',
+                  finding_type: 'evidence_backed_semantic_finding',
+                });
+              }
+            }
+          }
+        }
+      }
+    }
+
+    // 2. Check promptResults
+    for (const pr of ctx.promptResults || []) {
+      if (!pr.answer_text) continue;
+      for (const e of entities) {
+        const evalRes = evaluateAnswerAttribution(pr.answer_text, e, { claims, reviewer: pr.evaluator });
+        if (evalRes.mentioned && evalRes.has_distorted_claims) {
+          for (const evalItem of evalRes.evaluations) {
+            if (evalItem.attribution_status === 'distorted') {
+              hits.push({
+                subject: entrySubject('claims', evalItem.claim_id),
+                summary: `Generative engine ${pr.engine || 'unknown'} attributes distorted claim "${evalItem.claim_id}" to entity "${e.canonical_name}"`,
+                evidence: [
+                  `engine: ${pr.engine || 'unknown'}`,
+                  `prompt: ${pr.prompt_text || pr.prompt_id || 'unknown'}`,
+                  `claim_id: ${evalItem.claim_id}`,
+                  `assertion_excerpt: "${evalItem.assertion_excerpt}"`,
+                  `reasons: ${(evalItem.reasons || []).join('; ')}`,
+                  `reviewer: ${pr.evaluator || 'unreviewed (semantic review required)'}`,
+                ],
+                confidence: pr.evaluator ? 'confirmed' : 'medium',
+                finding_type: 'evidence_backed_semantic_finding',
+              });
+            }
+          }
+        }
+      }
+    }
+
+    const seen = new Set();
+    return hits.filter((h) => {
+      const k = `${h.subject.identifier}|${h.summary}`;
+      if (seen.has(k)) return false;
+      seen.add(k);
+      return true;
+    });
+  },
+}));
+
+D.push(defineDetector({
+  id: 'GEO-009', name: 'Unstable citation presence across repeated probes', namespace: 'GEO',
+  description: 'Brand citation status exhibits high volatility or flapping (alternating between cited and unmentioned) across repeated probe runs for the same prompt and engine.',
+  discipline: ['geo', 'aeo'], severity: 'medium', deterministic: false, requires: ['registries'],
+  finding_type: 'evidence_backed_semantic_finding',
+  impact: { representation: 'high', citation: 'high' },
+  applicable_requirement: 'GEO §6 generative retrieval stability; longitudinal observation controls; answer-engine variance tracking',
+  false_positive_conditions: ['Deliberate query variation or divergent test prompts'],
+  remediation: 'Strengthen entity salience and disambiguation in target content, improve passage answer density, and establish consistent external corroboration for core claims.',
+  unsafe_shortcuts: ['over-optimizing phrasing to trigger keyword matching in a single model version'],
+  verification: 'Subsequent repeated probe runs demonstrate stable citation presence (presence rate >= 80% with low flapping).',
+  check(ctx) {
+    const hits = [];
+    const groups = new Map();
+
+    // 1. Group citation observations by prompt + provider
+    for (const obs of ctx.observations || []) {
+      if (obs.kind !== 'citation' || !obs.data) continue;
+      const promptKey = obs.data.prompt_id || obs.data.prompt_text;
+      if (!promptKey) continue;
+      const provider = obs.data.provider || 'unknown';
+      const key = `${promptKey}|${provider}`;
+      if (!groups.has(key)) groups.set(key, { prompt: promptKey, provider, samples: [] });
+      groups.get(key).samples.push(Boolean(obs.data.property_cited));
+    }
+
+    // 2. Also group promptResults if present
+    for (const pr of ctx.promptResults || []) {
+      const promptKey = pr.prompt_id || pr.prompt_text;
+      if (!promptKey) continue;
+      const provider = pr.engine || 'unknown';
+      const key = `${promptKey}|${provider}`;
+      if (!groups.has(key)) groups.set(key, { prompt: promptKey, provider, samples: [] });
+      const cited = pr.cited !== undefined ? Boolean(pr.cited) : (pr.citations && pr.citations.length > 0);
+      groups.get(key).samples.push(Boolean(cited));
+    }
+
+    // Evaluate each group with at least 3 samples
+    for (const { prompt, provider, samples } of groups.values()) {
+      if (samples.length < 3) continue;
+      const total = samples.length;
+      const citedCount = samples.filter(Boolean).length;
+      const presenceRate = citedCount / total;
+
+      // Calculate transitions (flapping)
+      let flips = 0;
+      for (let i = 1; i < samples.length; i++) {
+        if (samples[i] !== samples[i - 1]) flips++;
+      }
+      const flappingRate = flips / (total - 1);
+
+      // Flapping threshold: presence rate between 20% and 80% with at least 1 flip, or flapping rate >= 0.4
+      if ((presenceRate >= 0.2 && presenceRate <= 0.8 && flips >= 1) || flappingRate >= 0.4) {
+        const volatility = (1 - Math.abs(presenceRate - 0.5) * 2).toFixed(2);
+        hits.push({
+          subject: entrySubject('prompts', prompt),
+          summary: `High citation volatility for "${prompt}" on ${provider}: cited in ${citedCount}/${total} runs (${Math.round(presenceRate * 100)}% presence rate)`,
+          evidence: [
+            `provider: ${provider}`,
+            `prompt: ${prompt}`,
+            `total_probes: ${total}`,
+            `cited_count: ${citedCount}`,
+            `presence_rate: ${(presenceRate * 100).toFixed(1)}%`,
+            `flapping_rate: ${(flappingRate * 100).toFixed(1)}% (${flips} state flips)`,
+            `volatility_score: ${volatility}`,
+            `sample_sequence: [${samples.map((s) => (s ? 'cited' : 'omitted')).join(', ')}]`,
+          ],
+          confidence: total >= 5 ? 'confirmed' : 'medium',
+          captured: { presenceRate, flappingRate, volatility: Number(volatility), samples: total },
+          expected: 'stable citation presence (presence rate >= 80% with low flapping)',
+        });
+      }
+    }
+
+    return hits;
+  },
+}));
+
+D.push(defineDetector({
+  id: 'GEO-010', name: 'Brand erasure in multi-competitor category prompt', namespace: 'GEO',
+  description: 'A generative engine observation for a relevant category or comparison prompt cites multiple registered competitors but completely omits the first-party entity or brand.',
+  discipline: ['geo', 'aeo'], severity: 'high', deterministic: false, requires: ['registries'],
+  impact: { representation: 'high', conversion: 'medium' },
+  applicable_requirement: 'GEO §6 entity representation in competitive category synthesis; GEO §1 share of model parity',
+  remediation: 'Publish comparative evidence, authoritative category definitions, and benchmark substantiation to establish entity co-occurrence in generative training and retrieval corpora.',
+  verification: 'Follow-up category engine observations cite the first-party brand alongside peers.',
+  check(ctx) {
+    const competitors = ctx.registries?.competitors?.entries || [];
+    if (competitors.length < 2) return [];
+    const entities = (ctx.registries?.entities?.entries || []).filter((e) => e.status !== 'retired');
+    if (!entities.length) return [];
+
+    const firstPartyNames = [];
+    for (const e of entities) {
+      if (e.canonical_name) firstPartyNames.push(e.canonical_name.toLowerCase());
+      for (const a of e.aliases || []) firstPartyNames.push(a.toLowerCase());
+    }
+
+    const hits = [];
+    for (const obs of ctx.observations || []) {
+      const d = obs.data || {};
+      const answer = d.answer_text || '';
+      const lowerAnswer = answer.toLowerCase();
+
+      // Check if first-party brand is omitted
+      const firstPartyCited = d.property_cited === true || firstPartyNames.some((n) => lowerAnswer.includes(n));
+      if (firstPartyCited) continue;
+
+      let citedCompetitors = [];
+      if (Array.isArray(d.competitors_cited) && d.competitors_cited.length > 0) {
+        citedCompetitors = d.competitors_cited;
+      } else if (answer) {
+        citedCompetitors = competitors.filter((c) => {
+          const cNames = [c.name, ...(c.aliases || [])].filter(Boolean);
+          return cNames.some((cn) => lowerAnswer.includes(cn.toLowerCase()));
+        }).map((c) => c.name);
+      }
+
+      if (citedCompetitors.length >= 2) {
+        const promptLabel = d.prompt_id || d.prompt_text || 'category prompt';
+        const engineLabel = d.provider || d.engine || 'generative engine';
+        hits.push({
+          subject: entrySubject('prompts', promptLabel),
+          summary: `Brand erased in category response by ${engineLabel}: ${citedCompetitors.length} competitors cited (${citedCompetitors.slice(0, 3).join(', ')}), 0 first-party mentions`,
+          evidence: [
+            `engine: ${engineLabel}`,
+            `prompt: ${promptLabel}`,
+            `competitors cited: ${citedCompetitors.join(', ')}`,
+            'first-party mentions: 0',
+          ],
+          confidence: 'high',
+        });
+      }
+    }
+    return hits;
+  },
+}));
+
+D.push(defineDetector({
+  id: 'GEO-011', name: 'RAG chunk fracture: claim separated from citation across oversized section', namespace: 'GEO',
+  description: 'A section under a single heading exceeds 450 words without structural sub-headings or lists, separating claims from qualifying citations and causing retrieval fracture in RAG chunking pipelines.',
+  discipline: ['geo', 'aeo'], severity: 'medium', deterministic: true, requires: ['site'],
+  impact: { retrieval: 'medium', representation: 'high' },
+  applicable_requirement: 'GEO §4 RAG semantic chunk boundary preservation; AEO §4 modular evidence proximity',
+  remediation: 'Subdivide sections exceeding 400 words with H3 sub-headings or bullet lists, and anchor citations in the same paragraph as the claim.',
+  verification: 'Re-audit section word counts and ensure paragraphs with factual claims contain adjacent citation anchors.',
+  check(ctx) {
+    const hits = [];
+    for (const p of indexTargets(ctx)) {
+      if (p.status !== 200 || !p.rawHtml) continue;
+      const paragraphs = p.paragraphs || [];
+      if (paragraphs.length < 4) continue;
+
+      let currentHeading = 'intro';
+      let currentWords = 0;
+      let hasClaimInChunk = false;
+      const CLAIM_RX = /\b(?:\d+%\s*(?:reduction|faster|increase|savings?)|SOC\s*2|GDPR|ISO\s*27001|compliant|verified|guaranteed)\b/i;
+      const CITE_RX = /\[\d+\]|href=|\(source:|\(see\s+|according\s+to|citation/i;
+
+      for (const para of paragraphs) {
+        const words = para.split(/\s+/).length;
+        currentWords += words;
+        if (CLAIM_RX.test(para) && !CITE_RX.test(para)) {
+          hasClaimInChunk = true;
+        }
+
+        if (currentWords > 450 && hasClaimInChunk) {
+          hits.push({
+            subject: pageSubject(p),
+            summary: `Oversized section under "${currentHeading.slice(0, 50)}" (${currentWords} words) risks RAG chunk fracture for unanchored claims`,
+            evidence: [
+              `section heading: "${currentHeading}"`,
+              `accumulated section words: ${currentWords}`,
+              'generative search RAG pipelines chunk text at 300-500 tokens, severing unanchored claims from qualifying context',
+            ],
+            captured: { section: currentHeading, wordCount: currentWords },
+            expected: '<= 400 words per section before sub-heading',
+          });
+          break;
+        }
+      }
+    }
+    return hits;
+  },
+}));
+
+D.push(defineDetector({
+  id: 'GEO-012', name: 'Repetitive phrase stuffing in section headings degrading dense retrieval', namespace: 'GEO',
+  description: 'Multiple headings repeat the identical multi-word phrase or entity prefix, degrading dense vector discriminability and triggering keyword stuffing penalties in neural search rankers.',
+  discipline: ['geo', 'seo'], severity: 'low', deterministic: true, requires: ['site'],
+  impact: { retrieval: 'medium', ranking: 'low' },
+  applicable_requirement: 'GEO §4 semantic vector distinctiveness; SEO §4 heading diversity and keyword stuffing avoidance',
+  remediation: 'Diversify section headings to reflect specific sub-topics, user questions, or tasks rather than repeating the same keyword stem.',
+  verification: 'Ensure no multi-word phrase is repeated across more than 3 headings.',
+  check(ctx) {
+    const hits = [];
+    for (const p of indexTargets(ctx)) {
+      if (p.status !== 200 || !p.headings || p.headings.length < 5) continue;
+      const headingTexts = p.headings.map((h) => (h.text || '').toLowerCase().trim()).filter(Boolean);
+
+      const ngramCounts = new Map();
+      for (const text of headingTexts) {
+        const words = text.split(/\s+/).filter((w) => w.length > 2);
+        for (let i = 0; i <= words.length - 2; i++) {
+          const gram2 = words.slice(i, i + 2).join(' ');
+          ngramCounts.set(gram2, (ngramCounts.get(gram2) || 0) + 1);
+          if (i <= words.length - 3) {
+            const gram3 = words.slice(i, i + 3).join(' ');
+            ngramCounts.set(gram3, (ngramCounts.get(gram3) || 0) + 1);
+          }
+        }
+      }
+
+      let repeatedGram = null;
+      let maxCount = 0;
+      for (const [gram, count] of ngramCounts) {
+        if (count >= 4 && count > maxCount) {
+          maxCount = count;
+          repeatedGram = gram;
+        }
+      }
+
+      if (repeatedGram && maxCount >= 4 && (maxCount / headingTexts.length) >= 0.4) {
+        hits.push({
+          subject: pageSubject(p),
+          summary: `Repetitive phrase "${repeatedGram}" repeated in ${maxCount}/${headingTexts.length} headings`,
+          evidence: [
+            `repeated phrase: "${repeatedGram}"`,
+            `occurrence: ${maxCount} headings (${Math.round((maxCount / headingTexts.length) * 100)}%)`,
+            'dense retrieval and bi-encoder embeddings suffer loss of discriminability from repetitive heading stems',
+          ],
+          captured: { phrase: repeatedGram, count: maxCount, totalHeadings: headingTexts.length },
+          expected: 'repeated phrase in <= 3 headings',
+        });
+      }
+    }
+    return hits;
+  },
+}));
+
+D.push(defineDetector({
+  id: 'GEO-013', name: 'AI engine assertion contradicts verified publisher claim registry', namespace: 'GEO',
+  description: 'An external AI search engine or generative model assertion directly contradicts or negates a verified publisher claim registered in claims.yaml.',
+  discipline: ['geo', 'aeo'], severity: 'high', deterministic: true, requires: ['observations', 'registries'],
+  impact: { representation: 'high', citation: 'high' },
+  applicable_requirement: 'GEO §13 AI hallucination and claim contradiction governance; AEO §2 factual integrity',
+  remediation: 'Publish explicit corroborating evidence on high-authority pages and submit model feedback/correction citations addressing the contradicted fact.',
+  verification: 'All generative AI assertions corroborate verified publisher claims without factual contradiction.',
+  check(ctx) {
+    const hits = [];
+    const claims = ctx.registries?.claims?.entries || [];
+    const verifiedClaims = claims.filter((c) => c.status === 'verified');
+    if (verifiedClaims.length === 0) return hits;
+
+    const observations = ctx.observations || [];
+    for (const obs of observations) {
+      if (obs.data?.contradiction_detected) {
+        hits.push({
+          subject: { type: 'registry_entry', identifier: `claims/${obs.data.claim_id || 'unspecified'}` },
+          summary: `AI engine ${obs.data.provider || 'unknown'} assertion contradicts verified claim "${obs.data.claim_id || 'unspecified'}"`,
+          evidence: [
+            `provider: ${obs.data.provider || 'unknown'}`,
+            `prompt: "${obs.data.prompt_text || 'prompt'}"`,
+            `contradicted assertion: "${obs.data.contradicted_assertion || obs.data.raw_response || ''}"`,
+            `claim: "${obs.data.claim_text || ''}"`,
+          ],
+          captured: { provider: obs.data.provider, claim_id: obs.data.claim_id, assertion: obs.data.contradicted_assertion },
+          expected: 'AI answer corroborates verified claim',
+        });
+        continue;
+      }
+
+      if (obs.data?.raw_response || obs.data?.assertion) {
+        const responseText = (obs.data.raw_response || obs.data.assertion || '').toLowerCase();
+        for (const vc of verifiedClaims) {
+          if (!vc.claim) continue;
+          const subjectMatch = vc.claim.match(/(?:supports|provides|features|certified|complies with)\s+([^,\.]+)/i);
+          if (subjectMatch) {
+            const feature = subjectMatch[1].toLowerCase().trim();
+            const negationRegex = new RegExp(`\\b(does not support|doesn't support|lacks|no support for|not certified|unsupported|fails to support)\\s+${feature.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&')}`, 'i');
+            if (negationRegex.test(responseText)) {
+              hits.push({
+                subject: { type: 'registry_entry', identifier: `claims/${vc.claim_id}` },
+                summary: `AI engine ${obs.data.provider || 'unknown'} assertion contradicts verified claim "${vc.claim_id}" (${feature})`,
+                evidence: [
+                  `provider: ${obs.data.provider || 'unknown'}`,
+                  `prompt: "${obs.data.prompt_text || 'prompt'}"`,
+                  `contradictory assertion: "${negationRegex.exec(responseText)?.[0] || 'negated assertion'}"`,
+                  `verified claim: "${vc.claim}"`,
+                ],
+                captured: { provider: obs.data.provider, claim_id: vc.claim_id, feature },
+                expected: `AI answer reflects verified claim: "${vc.claim}"`,
+              });
+            }
+          }
+        }
+      }
+    }
+
+    return hits;
+  },
+}));
+
 /* ---------------- RECO: recommendation eligibility ---------------- */
 
 const RECO_CHECKS = [