@nebulacomponents/citable 0.1.0

package/src/detectors/geoReco.js

@@ -0,0 +1,218 @@
+import { defineDetector, indexTargets, registryPageFor, sitePageFor, pageSubject, entrySubject } from './framework.js';
+
+const D = [];
+
+/* ---------------- EXT: external corroboration ---------------- */
+
+D.push(defineDetector({
+  id: 'EXT-001', name: 'Corroboration claimed from owned surface', namespace: 'EXT',
+  description: 'A claim lists "external corroboration" whose source is the organization’s own domain — self-corroboration.',
+  discipline: ['aeo', 'geo'], severity: 'medium', deterministic: true, requires: ['registries'],
+  impact: { representation: 'medium', reputational: 'medium' },
+  applicable_requirement: 'AEO §7: corroboration must be editorially independent; premise 3.6',
+  remediation: 'Move the reference to evidence (owned) and pursue genuinely independent corroboration.',
+  verification: 'External corroboration entries resolve to non-owned domains.',
+  check(ctx) {
+    const ownDomains = new Set();
+    try { ownDomains.add(new URL(ctx.config?.site?.base_url ?? 'https://invalid.test').hostname); } catch { /* no base url */ }
+    const ev = new Map((ctx.registries.evidence?.entries || []).map((e) => [e.evidence_id, e]));
+    const hits = [];
+    for (const c of ctx.registries.claims?.entries || []) {
+      for (const ref of c.external_corroboration || []) {
+        const e = ev.get(ref);
+        const src = e?.source ?? (typeof ref === 'string' && ref.startsWith('http') ? ref : null);
+        if (!src) continue;
+        try {
+          if (ownDomains.has(new URL(src).hostname)) {
+            hits.push({
+              subject: entrySubject('claims', c.claim_id),
+              summary: `External corroboration for claim ${c.claim_id} points at owned domain ${new URL(src).hostname}`,
+              evidence: [`corroboration source: ${src}`],
+            });
+          }
+        } catch { /* non-URL sources cannot be classified */ }
+      }
+    }
+    return hits;
+  },
+}));
+
+D.push(defineDetector({
+  id: 'EXT-002', name: 'Comparative claim lacking independent corroboration', namespace: 'EXT',
+  description: 'A verified comparative claim has no external corroboration recorded at all.',
+  discipline: ['geo'], severity: 'low', deterministic: true, requires: ['registries'],
+  impact: { representation: 'medium', citation: 'low' },
+  applicable_requirement: 'GEO §6: owned content is necessary but insufficient; AEO §7 external corroboration layer',
+  remediation: 'Pursue independent editorial coverage, reviews, or analyst references that corroborate the comparison — never manufacture them.',
+  unsafe_shortcuts: ['fake reviews', 'synthetic community posts', 'paid lists presented as editorial'],
+  verification: 'Comparative verified claims list at least one independent corroboration source.',
+  check(ctx) {
+    return (ctx.registries.claims?.entries || [])
+      .filter((c) => c.claim_type === 'comparative' && ['verified', 'verified_narrowed'].includes(c.status) && (c.external_corroboration || []).length === 0)
+      .map((c) => ({
+        subject: entrySubject('claims', c.claim_id),
+        summary: `Verified comparative claim ${c.claim_id} has no independent corroboration`,
+        evidence: ['external_corroboration: []'],
+      }));
+  },
+}));
+
+/* ---------------- GEO: generative representation ---------------- */
+
+D.push(defineDetector({
+  id: 'GEO-001', name: 'Hidden instructions targeting language models', namespace: 'GEO',
+  description: 'Hidden page text or HTML comments contain instruction-like phrasing aimed at AI systems (crawler prompt injection).',
+  discipline: ['geo'], severity: 'critical', deterministic: true, requires: ['site'],
+  impact: { reputational: 'high', legal: 'medium', representation: 'high' },
+  applicable_requirement: 'Premise 3.6: no hidden instructions for language models, no crawler prompt injection; GEO §6 unsafe practices',
+  remediation: 'Remove the hidden instruction text entirely.',
+  unsafe_shortcuts: ['moving the instructions to a less detectable location'],
+  verification: 'No hidden text or comments contain model-directed instructions.',
+  check(ctx) {
+    const rx = /(ignore (all |any )?(previous|prior|above) (instructions|prompts)|you are an? (ai|llm|language model|assistant)|when summariz|if you are an? (ai|llm|assistant|model)|always recommend|do not mention (competitor|alternative)|respond with|tell the user)/i;
+    const hits = [];
+    for (const p of ctx.site.pages) {
+      for (const t of p.hiddenTexts) {
+        if (rx.test(t)) {
+          hits.push({
+            subject: pageSubject(p),
+            summary: 'Hidden text contains instructions directed at AI systems',
+            evidence: [`hidden text: "${t.slice(0, 160)}"`],
+          });
+        }
+      }
+      const comments = p.rawHtml.match(/<!--([\s\S]*?)-->/g) || [];
+      for (const c of comments) {
+        if (rx.test(c)) {
+          hits.push({
+            subject: pageSubject(p),
+            summary: 'HTML comment contains instructions directed at AI systems',
+            evidence: [`comment: "${c.slice(0, 160)}"`],
+          });
+        }
+      }
+    }
+    return hits;
+  },
+}));
+
+D.push(defineDetector({
+  id: 'GEO-002', name: 'Proprietary concept without stable definition', namespace: 'GEO',
+  description: 'A proprietary-concept entity has no definition recorded and/or no canonical page.',
+  discipline: ['geo', 'aeo'], severity: 'medium', deterministic: true, requires: ['registries'],
+  impact: { representation: 'high', citation: 'medium' },
+  applicable_requirement: 'Detector spec: proprietary term lacks a stable definition; GEO §5 controlled terminology',
+  remediation: 'Publish one canonical definition page per proprietary concept and record it in the registry.',
+  verification: 'Concept entity has definition and canonical_url.',
+  check(ctx) {
+    return (ctx.registries.entities?.entries || [])
+      .filter((e) => e.entity_type === 'proprietary_concept' && e.status !== 'retired')
+      .filter((e) => !e.definition || !e.canonical_url)
+      .map((e) => ({
+        subject: entrySubject('entities', e.entity_id),
+        summary: `Proprietary concept "${e.canonical_name}" lacks ${!e.definition ? 'a definition' : ''}${!e.definition && !e.canonical_url ? ' and ' : ''}${!e.canonical_url ? 'a canonical page' : ''}`,
+        evidence: [`definition: ${e.definition ? 'present' : 'missing'}; canonical_url: ${e.canonical_url ?? 'missing'}`],
+      }));
+  },
+}));
+
+D.push(defineDetector({
+  id: 'GEO-003', name: 'Entity absent from its category page', namespace: 'GEO',
+  description: 'A product entity declares a category for which a category page exists, but the page never mentions the entity.',
+  discipline: ['geo'], severity: 'medium', deterministic: true, requires: ['site', 'registries'],
+  impact: { representation: 'medium', citation: 'low' },
+  applicable_requirement: 'Detector spec: entity omitted from its relevant category page; GEO §3 category placement',
+  remediation: 'Reference the entity (with its canonical name) on the category page it belongs to.',
+  verification: 'Category page text contains the entity canonical name or an alias.',
+  check(ctx) {
+    const categoryPages = (ctx.registries.pages?.entries || []).filter((p) => p.page_type === 'category' && p.status !== 'retired');
+    if (categoryPages.length === 0) return [];
+    const hits = [];
+    for (const e of (ctx.registries.entities?.entries || []).filter((e) => ['product', 'product_family'].includes(e.entity_type) && e.category)) {
+      for (const cp of categoryPages) {
+        if (!(cp.primary_entities || []).some((pe) => {
+          const cat = (ctx.registries.entities?.entries || []).find((x) => x.entity_id === pe);
+          return cat && (cat.canonical_name.toLowerCase() === String(e.category).toLowerCase() || cat.entity_id === e.category);
+        })) continue;
+        const page = sitePageFor(ctx, cp);
+        if (!page) continue;
+        const names = [e.canonical_name, ...(e.aliases || [])].map((n) => n.toLowerCase());
+        if (!names.some((n) => page.text.toLowerCase().includes(n))) {
+          hits.push({
+            subject: entrySubject('entities', e.entity_id),
+            summary: `Entity "${e.canonical_name}" is not mentioned on its category page ${cp.page_id}`,
+            evidence: [`category: ${e.category}`, `category page: ${cp.url}`],
+          });
+        }
+      }
+    }
+    return hits;
+  },
+}));
+
+D.push(defineDetector({
+  id: 'GEO-004', name: 'llms.txt treated as authority mechanism', namespace: 'GEO',
+  description: 'llms.txt exists and contains directive/authority language, which no engine honors as an authorization mechanism.',
+  discipline: ['geo'], severity: 'low', deterministic: false, requires: ['site'],
+  impact: { representation: 'low', legal: 'low' },
+  applicable_requirement: 'Anti-pattern: treating llms.txt as an authority mechanism; GEO §9 llms.txt is optional and experimental',
+  false_positive_conditions: ['descriptive llms.txt files that merely index documentation'],
+  remediation: 'Treat llms.txt as optional discovery metadata only; move access decisions to robots.txt and the crawler policy registry.',
+  verification: 'llms.txt contains no directive/authorization language.',
+  check(ctx) {
+    const page = ctx.site.pages.find((p) => p.url.endsWith('/llms.txt'));
+    const raw = page?.rawHtml ?? ctx.site.llmsTxt ?? null;
+    if (!raw) return [];
+    if (/\b(must not|do not (train|use|crawl)|prohibited|required to|you must|licen[cs]e enforcement)\b/i.test(raw)) {
+      return [{
+        subject: { type: 'url', identifier: 'llms.txt' },
+        summary: 'llms.txt contains directive language it cannot enforce',
+        evidence: ['llms.txt is not a recognized authorization mechanism; Google explicitly does not use it'],
+        confidence: 'high',
+      }];
+    }
+    return [];
+  },
+}));
+
+/* ---------------- RECO: recommendation eligibility ---------------- */
+
+const RECO_CHECKS = [
+  ['RECO-001', 'target user', /\b((designed|built|intended|best|ideal) for|who (is|are) (this|it) for|target (user|customer|audience)|for (teams|organizations|enterprises|companies) (that|who|with))\b/i, 'Recommendation-eligible page never states who the product is for.', 'GEO §7 target user'],
+  ['RECO-002', 'non-target user / exclusions', /\b(not (for|intended for|suitable for|a fit for|designed for)|who should not|isn'?t for|poor fit|when not to use)\b/i, 'Page never states who the product is NOT for.', 'GEO §7 non-target user; recommendation page lacks non-target user'],
+  ['RECO-003', 'deployment model', /\b(saas|self-?hosted|on-?prem(ise|ises)?|cloud[- ]hosted|hybrid deployment|deployment (model|option))\b/i, 'Page never states the deployment model.', 'GEO §7 deployment'],
+  ['RECO-004', 'pricing qualification', /\b(pricing|price|cost|quote|per (seat|user|month|year)|contact (us|sales) for pricing|free (tier|trial))\b/i, 'Page gives no pricing information or qualification.', 'GEO §7 pricing public or clearly qualified'],
+  ['RECO-005', 'limitations', /\b(limitation|constraint|does not (support|cover|solve)|not (yet )?(supported|available)|known (issue|limitation)|trade-?off)\b/i, 'Page states no limitations.', 'GEO §7 limitations; detector spec: missing limitations'],
+  ['RECO-006', 'geography', /\b(available in|supported (market|countr|region)|north america|europe|global(ly)? available|jurisdiction)\b/i, 'Page never states supported geography.', 'GEO §7 geography'],
+];
+
+for (const [id, label, rx, desc, req] of RECO_CHECKS) {
+  D.push(defineDetector({
+    id, name: `Recommendation data missing: ${label}`, namespace: 'RECO',
+    description: desc,
+    discipline: ['geo'], severity: 'medium', deterministic: false, requires: ['site', 'registries'],
+    impact: { representation: 'high', conversion: 'medium' },
+    applicable_requirement: req,
+    false_positive_conditions: [`${label} expressed with vocabulary outside the matched set`],
+    remediation: `State the ${label} explicitly on product and recommendation pages.`,
+    verification: `${label} phrasing present on the page.`,
+    check(ctx) {
+      const hits = [];
+      for (const p of indexTargets(ctx)) {
+        const reg = registryPageFor(ctx, p);
+        if (!reg || !['product', 'recommendation'].includes(reg.page_type) || p.status !== 200) continue;
+        if (!rx.test(p.text)) {
+          hits.push({
+            subject: pageSubject(p),
+            summary: `${reg.page_type} page ${reg.page_id}: no ${label} stated`,
+            evidence: [`no ${label} phrasing found in page text`],
+            confidence: 'medium',
+          });
+        }
+      }
+      return hits;
+    },
+  }));
+}
+
+export default D;

package/src/detectors/index.js

@@ -0,0 +1,50 @@
+import tech from './tech.js';
+import crawl from './crawl.js';
+import arch from './arch.js';
+import page from './page.js';
+import ans from './ans.js';
+import entity from './entity.js';
+import claim from './claim.js';
+import evd from './evd.js';
+import schemaData from './schemaData.js';
+import link from './link.js';
+import geoReco from './geoReco.js';
+import lifeMeas from './lifeMeas.js';
+
+export const ALL_DETECTORS = [...tech, ...crawl, ...arch, ...page, ...ans, ...entity, ...claim, ...evd, ...schemaData, ...link, ...geoReco, ...lifeMeas];
+
+const ids = new Set();
+for (const d of ALL_DETECTORS) {
+  if (ids.has(d.id)) throw new Error(`duplicate detector id: ${d.id}`);
+  ids.add(d.id);
+}
+
+export function detectorsByNamespace() {
+  const out = {};
+  for (const d of ALL_DETECTORS) (out[d.namespace] ||= []).push(d);
+  return out;
+}
+
+export function selectDetectors({ scope, namespaces, discipline } = {}) {
+  let ds = ALL_DETECTORS;
+  if (namespaces?.length) ds = ds.filter((d) => namespaces.includes(d.namespace));
+  if (discipline) ds = ds.filter((d) => d.discipline.includes(discipline));
+  if (scope) {
+    const scopeMap = {
+      technical: ['TECH', 'CRAWL', 'LINK'],
+      seo: null, // discipline filter handles it
+      aeo: null,
+      geo: null,
+      architecture: ['ARCH', 'LINK'],
+      entity: ['ENTITY'],
+      claims: ['CLAIM'],
+      evidence: ['EVD'],
+      schema: ['SCHEMA'],
+      lifecycle: ['LIFE'],
+      corroboration: ['EXT'],
+    };
+    if (scopeMap[scope]) ds = ds.filter((d) => scopeMap[scope].includes(d.namespace));
+    else if (['seo', 'aeo', 'geo'].includes(scope)) ds = ds.filter((d) => d.discipline.includes(scope));
+  }
+  return ds;
+}

package/src/detectors/lifeMeas.js

@@ -0,0 +1,212 @@
+import { defineDetector, entrySubject } from './framework.js';
+import { isPastDate } from '../shared/io.js';
+
+const D = [];
+
+/* ---------------- LIFE: lifecycle and ownership ---------------- */
+
+D.push(defineDetector({
+  id: 'LIFE-001', name: 'Page without content owner', namespace: 'LIFE',
+  description: 'An active page registry entry has no accountable content owner.',
+  discipline: ['seo', 'aeo', 'geo'], severity: 'medium', deterministic: true, requires: ['registries'],
+  impact: { maintainability: 'high' },
+  applicable_requirement: 'SEO §14 lifecycle: owner assigned; AEO §13 content owner assigned',
+  remediation: 'Assign a named accountable content owner.',
+  verification: 'content_owner set on all active pages.',
+  check(ctx) {
+    return activePages(ctx).filter((p) => !p.content_owner).map((p) => ({
+      subject: entrySubject('pages', p.page_id),
+      summary: `Page ${p.page_id} has no content owner`,
+      evidence: ['content_owner: missing'],
+    }));
+  },
+}));
+
+D.push(defineDetector({
+  id: 'LIFE-002', name: 'Claim-bearing page without factual reviewer', namespace: 'LIFE',
+  description: 'A page that publishes registered claims has no factual reviewer.',
+  discipline: ['aeo', 'geo'], severity: 'medium', deterministic: true, requires: ['registries'],
+  impact: { legal: 'medium', maintainability: 'medium' },
+  applicable_requirement: 'AEO §8 required update controls: factual reviewer; SEO §12 subject-matter expert role',
+  remediation: 'Assign a factual reviewer for pages that publish claims.',
+  verification: 'factual_reviewer set on claim-bearing pages.',
+  check(ctx) {
+    return activePages(ctx)
+      .filter((p) => (p.published_claims || []).length > 0 && !p.factual_reviewer)
+      .map((p) => ({
+        subject: entrySubject('pages', p.page_id),
+        summary: `Page ${p.page_id} publishes ${(p.published_claims || []).length} claim(s) but has no factual reviewer`,
+        evidence: [`published_claims: ${(p.published_claims || []).join(', ')}`],
+      }));
+  },
+}));
+
+D.push(defineDetector({
+  id: 'LIFE-003', name: 'Review overdue', namespace: 'LIFE',
+  description: 'A page has passed its next review date.',
+  discipline: ['seo', 'aeo', 'geo'], severity: 'medium', deterministic: true, requires: ['registries'],
+  impact: { representation: 'medium', maintainability: 'medium' },
+  applicable_requirement: 'AEO §8 lifecycle classification and review intervals; SEO §12 content review dates',
+  remediation: 'Perform the scheduled factual review and set the next review date.',
+  verification: 'next_review_date in the future for all active pages.',
+  check(ctx) {
+    return activePages(ctx)
+      .filter((p) => isPastDate(p.next_review_date, ctx.refDate))
+      .map((p) => ({
+        subject: entrySubject('pages', p.page_id),
+        summary: `Page ${p.page_id} review overdue (due ${p.next_review_date})`,
+        evidence: [`next_review_date: ${p.next_review_date}`],
+      }));
+  },
+}));
+
+D.push(defineDetector({
+  id: 'LIFE-004', name: 'Page without lifecycle classification', namespace: 'LIFE',
+  description: 'An active page has no lifecycle class, so no review model can apply.',
+  discipline: ['seo', 'aeo', 'geo'], severity: 'low', deterministic: true, requires: ['registries'],
+  impact: { maintainability: 'medium' },
+  applicable_requirement: 'AEO §8 every page needs a lifecycle classification; detector spec: content lacks lifecycle classification',
+  remediation: 'Classify the page (foundational, product_capability, regulatory, pricing, …) and derive its review cadence.',
+  verification: 'lifecycle_class set on all active pages.',
+  check(ctx) {
+    return activePages(ctx)
+      .filter((p) => !p.lifecycle_class || p.lifecycle_class === 'unclassified')
+      .map((p) => ({
+        subject: entrySubject('pages', p.page_id),
+        summary: `Page ${p.page_id} has no lifecycle classification`,
+        evidence: [`lifecycle_class: ${p.lifecycle_class ?? 'missing'}`],
+      }));
+  },
+}));
+
+D.push(defineDetector({
+  id: 'LIFE-005', name: 'Regulatory content without jurisdiction', namespace: 'LIFE',
+  description: 'A page classified regulatory (or carrying legal claims) records no jurisdiction.',
+  discipline: ['aeo', 'geo'], severity: 'medium', deterministic: true, requires: ['registries'],
+  impact: { legal: 'high' },
+  applicable_requirement: 'Detector spec: regulatory content lacks jurisdiction; AEO §1 jurisdiction field',
+  remediation: 'Record the jurisdiction the content applies to and state it on the page.',
+  verification: 'jurisdiction set on regulatory pages.',
+  check(ctx) {
+    const legalClaims = new Set((ctx.registries.claims?.entries || []).filter((c) => c.claim_type === 'legal_regulatory').map((c) => c.claim_id));
+    return activePages(ctx)
+      .filter((p) => (p.lifecycle_class === 'regulatory' || (p.published_claims || []).some((c) => legalClaims.has(c))) && !p.jurisdiction)
+      .map((p) => ({
+        subject: entrySubject('pages', p.page_id),
+        summary: `Regulatory page ${p.page_id} records no jurisdiction`,
+        evidence: [`lifecycle_class: ${p.lifecycle_class}; jurisdiction: missing`],
+      }));
+  },
+}));
+
+D.push(defineDetector({
+  id: 'LIFE-006', name: 'Freshness theater (date bumped, content unchanged)', namespace: 'LIFE',
+  description: 'Between snapshots, a page’s dateModified advanced while its content hash stayed identical.',
+  discipline: ['seo', 'aeo'], severity: 'medium', deterministic: true, requires: ['site', 'snapshots'],
+  impact: { reputational: 'medium', representation: 'medium' },
+  applicable_requirement: 'AEO §8 do not update dates without materially updating content ("freshness theater")',
+  remediation: 'Only advance revision dates alongside substantive updates.',
+  verification: 'Compare content hash and dateModified across snapshots.',
+  check(ctx) {
+    const prev = ctx.snapshots?.pages;
+    if (!prev) return [];
+    const hits = [];
+    for (const p of ctx.site.pages) {
+      const old = prev[p.url];
+      if (!old) continue;
+      const currentDate = extractModified(p);
+      if (old.contentHash && ctx.hashPage && old.contentHash === ctx.hashPage(p) && old.dateModified && currentDate && currentDate > old.dateModified) {
+        hits.push({
+          subject: { type: 'page', identifier: p.url, url: p.url },
+          summary: `dateModified advanced (${old.dateModified} → ${currentDate}) with identical content`,
+          evidence: [`content hash unchanged: ${old.contentHash.slice(0, 12)}…`],
+        });
+      }
+    }
+    return hits;
+  },
+}));
+
+export function extractModified(page) {
+  for (const j of page.jsonLd) {
+    for (const b of j.blocks) {
+      if (b.dateModified) return String(b.dateModified);
+    }
+  }
+  return page.metas?.['article:modified_time']?.[0] ?? null;
+}
+
+/* ---------------- MEAS: measurement integrity ---------------- */
+
+D.push(defineDetector({
+  id: 'MEAS-001', name: 'Prompt observation missing required metadata', namespace: 'MEAS',
+  description: 'A recorded prompt-test observation lacks engine, model/interface, locale, or timestamp context.',
+  discipline: ['geo', 'aeo'], severity: 'medium', deterministic: true, requires: ['promptResults'],
+  impact: { maintainability: 'high' },
+  applicable_requirement: '§8.8 test-prompts must record model, interface, locale, date; GEO §12 evidence capture',
+  remediation: 'Re-record the observation with full context; discard observations that cannot be contextualized.',
+  verification: 'All observations validate against prompt-result.schema.json.',
+  check(ctx) {
+    const hits = [];
+    for (const o of ctx.promptResults || []) {
+      const missing = ['engine', 'locale', 'date_time', 'prompt_text'].filter((k) => !o[k]);
+      if (missing.length) {
+        hits.push({
+          subject: { type: 'prompt', identifier: o.observation_id ?? o.prompt_id ?? 'unknown' },
+          summary: `Prompt observation missing: ${missing.join(', ')}`,
+          evidence: [`observation ${o.observation_id ?? '?'} lacks ${missing.join(', ')}`],
+        });
+      }
+    }
+    return hits;
+  },
+}));
+
+D.push(defineDetector({
+  id: 'MEAS-002', name: 'Single observation treated as stable outcome', namespace: 'MEAS',
+  description: 'A prompt has exactly one recorded observation but its registry accuracy_status asserts a definitive outcome.',
+  discipline: ['geo'], severity: 'medium', deterministic: true, requires: ['registries'],
+  impact: { maintainability: 'medium', representation: 'low' },
+  applicable_requirement: 'AEO §10 statistical caution: do not claim improvement from one prompt/one day; GEO §12 repeatability',
+  remediation: 'Collect repeated observations across engines, dates, and variants before recording a definitive accuracy status.',
+  verification: 'Prompts with definitive status have ≥3 observations.',
+  check(ctx) {
+    const counts = new Map();
+    for (const o of ctx.promptResults || []) {
+      counts.set(o.prompt_id, (counts.get(o.prompt_id) || 0) + 1);
+    }
+    return (ctx.registries.prompts?.entries || [])
+      .filter((p) => ['accurate', 'inaccurate'].includes(p.accuracy_status) && (counts.get(p.prompt_id) || 0) < 3)
+      .map((p) => ({
+        subject: entrySubject('prompts', p.prompt_id),
+        summary: `Prompt ${p.prompt_id} has definitive accuracy_status "${p.accuracy_status}" from only ${counts.get(p.prompt_id) || 0} observation(s)`,
+        evidence: [`observations recorded: ${counts.get(p.prompt_id) || 0}; minimum for definitive status: 3`],
+      }));
+  },
+}));
+
+D.push(defineDetector({
+  id: 'MEAS-003', name: 'Causal experiment conclusion without controls', namespace: 'MEAS',
+  description: 'A concluded experiment asserts a result but records no control group, baseline window, or confounders.',
+  discipline: ['seo', 'geo'], severity: 'medium', deterministic: true, requires: ['registries'],
+  impact: { maintainability: 'medium' },
+  applicable_requirement: 'SEO §11 required experiment record; GEO §14 invalid conclusion pattern',
+  remediation: 'Re-open the experiment with a control/baseline design, or downgrade the result confidence to low.',
+  verification: 'Concluded experiments carry control/baseline and confounders.',
+  check(ctx) {
+    return (ctx.registries.experiments?.entries || [])
+      .filter((e) => e.status === 'concluded' && e.result && e.result_confidence !== 'low')
+      .filter((e) => (!e.control_group && !e.baseline_window) || (e.known_confounders || []).length === 0)
+      .map((e) => ({
+        subject: entrySubject('experiments', e.experiment_id),
+        summary: `Experiment ${e.experiment_id} concludes "${String(e.result).slice(0, 60)}" without ${(!e.control_group && !e.baseline_window) ? 'control/baseline' : ''}${((!e.control_group && !e.baseline_window) && (e.known_confounders || []).length === 0) ? ' or ' : ''}${(e.known_confounders || []).length === 0 ? 'recorded confounders' : ''}`,
+        evidence: [`control_group: ${e.control_group ?? 'none'}; baseline_window: ${e.baseline_window ?? 'none'}; known_confounders: ${(e.known_confounders || []).length}`],
+      }));
+  },
+}));
+
+function activePages(ctx) {
+  return (ctx.registries.pages?.entries || []).filter((p) => !['retired', 'draft'].includes(p.status));
+}
+
+export default D;

package/src/detectors/link.js

@@ -0,0 +1,121 @@
+import { defineDetector, pageSubject } from './framework.js';
+
+const D = [];
+
+D.push(defineDetector({
+  id: 'LINK-001', name: 'Broken internal link', namespace: 'LINK',
+  description: 'An internal link targets a URL that is missing from the audited output or returns 4xx/5xx.',
+  discipline: ['seo', 'aeo'], severity: 'medium', deterministic: true, requires: ['site'],
+  impact: { retrieval: 'medium', conversion: 'low' },
+  applicable_requirement: 'SEO §12 broken internal-link detection; §2 crawlable internal links',
+  remediation: 'Fix or remove the link; add a redirect if the target moved.',
+  verification: 'All internal links resolve to 200 pages.',
+  check(ctx) {
+    const hits = [];
+    for (const p of ctx.site.pages) {
+      const seen = new Set();
+      for (const e of ctx.site.outbound.get(ctx.site.normalize(p.url)) || []) {
+        if (seen.has(e.to)) continue;
+        seen.add(e.to);
+        const target = ctx.site.byUrl.get(e.to);
+        if (!target) {
+          hits.push({
+            subject: pageSubject(p),
+            summary: `Internal link to missing URL ${e.to}`,
+            evidence: [`link "${e.text || e.href}" → ${e.to} (not found in audited output)`],
+          });
+        } else if (target.status >= 400) {
+          hits.push({
+            subject: pageSubject(p),
+            summary: `Internal link to ${e.to} returning HTTP ${target.status}`,
+            evidence: [`link "${e.text || e.href}" → ${e.to} (status ${target.status})`],
+          });
+        }
+      }
+    }
+    return hits;
+  },
+}));
+
+D.push(defineDetector({
+  id: 'LINK-002', name: 'Internal link to redirect', namespace: 'LINK',
+  description: 'An internal link targets a URL that redirects instead of the final destination.',
+  discipline: ['seo'], severity: 'low', deterministic: true, requires: ['site'],
+  impact: { retrieval: 'low' },
+  applicable_requirement: 'SEO §3 avoid links to redirects or canonical duplicates',
+  remediation: 'Update the link to the final destination URL.',
+  verification: 'Internal links point directly at 200 URLs.',
+  check(ctx) {
+    const hits = [];
+    for (const p of ctx.site.pages) {
+      for (const e of ctx.site.outbound.get(ctx.site.normalize(p.url)) || []) {
+        const target = ctx.site.byUrl.get(e.to);
+        if (target && target.status >= 300 && target.status < 400) {
+          hits.push({
+            subject: pageSubject(p),
+            summary: `Internal link to redirecting URL ${e.to} (HTTP ${target.status})`,
+            evidence: [`link "${e.text || e.href}" → ${e.to} (status ${target.status})`],
+          });
+        }
+      }
+    }
+    return hits;
+  },
+}));
+
+D.push(defineDetector({
+  id: 'LINK-003', name: 'Generic anchor text', namespace: 'LINK',
+  description: 'Internal links use non-descriptive anchors ("click here", "read more", "learn more").',
+  discipline: ['seo', 'aeo'], severity: 'low', deterministic: true, requires: ['site'],
+  impact: { ranking: 'low' },
+  applicable_requirement: 'SEO §3 meaningful anchor text; avoid "click here"',
+  remediation: 'Rewrite anchors to describe the target ("AI execution governance definition", not "learn more").',
+  verification: 'No internal anchors match the generic set.',
+  check(ctx) {
+    const generic = /^(click here|read more|learn more|here|more|this page|link)$/i;
+    const hits = [];
+    for (const p of ctx.site.pages) {
+      const bad = (ctx.site.outbound.get(ctx.site.normalize(p.url)) || []).filter((e) => generic.test(e.text));
+      if (bad.length) {
+        hits.push({
+          subject: pageSubject(p),
+          summary: `${bad.length} internal link(s) with generic anchor text`,
+          evidence: bad.slice(0, 5).map((e) => `"${e.text}" → ${e.to}`),
+        });
+      }
+    }
+    return hits;
+  },
+}));
+
+D.push(defineDetector({
+  id: 'LINK-004', name: 'Sitewide repeated exact-match anchor', namespace: 'LINK',
+  description: 'The same exact anchor text points at the same URL from a large share of pages — a pattern of mechanical link insertion.',
+  discipline: ['seo'], severity: 'low', deterministic: false, requires: ['site'],
+  impact: { ranking: 'low', reputational: 'low' },
+  applicable_requirement: 'SEO §3 avoid sitewide exact-match anchors and automated keyword-matched links',
+  false_positive_conditions: ['legitimate navigation labels (nav/footer) repeated by design'],
+  remediation: 'Vary contextual anchors naturally; keep repeated labels to navigation chrome only.',
+  verification: 'Re-measure anchor repetition after cleanup.',
+  check(ctx) {
+    if (ctx.site.pages.length < 5) return [];
+    const counts = new Map();
+    for (const p of ctx.site.pages) {
+      for (const e of ctx.site.outbound.get(ctx.site.normalize(p.url)) || []) {
+        if (!e.text || e.text.split(' ').length < 3) continue; // navigation labels are short; target phrase-anchors
+        const key = `${e.text.toLowerCase()}→${e.to}`;
+        counts.set(key, (counts.get(key) || 0) + 1);
+      }
+    }
+    return [...counts.entries()]
+      .filter(([, n]) => n >= Math.max(5, Math.ceil(ctx.site.pages.length * 0.8)))
+      .map(([key, n]) => ({
+        subject: { type: 'site', identifier: key },
+        summary: `Exact-match anchor repeated ${n} times sitewide: ${key.split('→')[0]}`,
+        evidence: [`${n} occurrences across ${ctx.site.pages.length} pages`],
+        confidence: 'medium',
+      }));
+  },
+}));
+
+export default D;