@imolko/ultra-agent 0.1.2-beta → 1.0.0-beta

package/scripts/adr-gate/text.mjs

@@ -0,0 +1,263 @@
+/**
+ * Compatibilidad de texto y rutas con el gate Python histórico.
+ *
+ * La salida del gate es un contrato (A-011, T-017): estas funciones replican
+ * `str.strip()`, `str.splitlines()`, `sorted()` por code point y
+ * `Path.resolve()` de Python. Cualquier cambio aquí cambia los golden files.
+ */
+
+import { lstatSync, readFileSync, readlinkSync } from "node:fs";
+import path from "node:path";
+
+/** Caracteres que `str.strip()` considera espacio en Python (incluye \x1c-\x1f y \x85). */
+const PY_WHITESPACE_CLASS =
+  "[\\t\\n\\v\\f\\r\\x1c-\\x1f \\x85\\xa0\\u1680\\u2000-\\u200a\\u2028\\u2029\\u202f\\u205f\\u3000]";
+const PY_STRIP_RE = new RegExp(
+  `^${PY_WHITESPACE_CLASS}+|${PY_WHITESPACE_CLASS}+$`,
+  "gu",
+);
+
+/** Separadores de `str.splitlines()` en Python. */
+const PY_LINE_BREAK_RE = /\r\n|[\r\n\v\f\x1c\x1d\x1e\x85\u2028\u2029]/g;
+
+/** Inicio de línea con la semántica de `re.MULTILINE`: solo después de `\n`. */
+const PY_LINE_START = "(?:^|(?<=\\n))";
+
+/** Mayor code point del plano básico; por encima, un code point ocupa dos unidades UTF-16. */
+const MAX_BMP_CODE_POINT = 0xffff;
+
+export const H1_RE = /^# (A|T|P)-\p{Nd}{3}: .+/u;
+
+export const ORIGINALLY_RE = new RegExp(`${PY_LINE_START}\\*\\*originally\\*\\*:`);
+export const ORIGINALLY_WRONG_RE = new RegExp(
+  `${PY_LINE_START}\\*\\*[Oo]riginally\\*\\*:`,
+);
+export const ENRICHED_RE = new RegExp(
+  `${PY_LINE_START}\\*\\*Enriquecido desde\\*\\*:`,
+);
+export const ENRICHED_WRONG_RE = new RegExp(
+  `${PY_LINE_START}\\*\\*[Ee]nriquecido [Dd]esde\\*\\*:`,
+);
+export const ESTADO_RE = new RegExp(
+  `${PY_LINE_START}\\*\\*Estado\\*\\*: ?([^\\n]+)(?=\\n|$)`,
+);
+
+/** Citas en texto plano a un ID de ADR, con `\b` y `\d` Unicode como en Python. */
+export const PLAIN_ID_RE =
+  /(?<![\p{L}\p{N}_])([A-Z]{1,2})-\p{Nd}{3}(?![\p{L}\p{N}_])/gu;
+
+/** Destino de un enlace markdown inline `](destino)` para la regla `enlaces`. */
+export const LINK_DEST_RE = /\]\(([^)]+)\)/gu;
+
+/** Destino de un enlace markdown inline que se elimina antes del escaneo de
+ * texto plano de la regla `jerarquia`. */
+export const LINK_TARGET_RE = /\]\([^)]*\)/gu;
+
+/** Enlace markdown inline completo: etiqueta y destino. */
+export const LINK_RE = /\[([^\]]*)\]\(([^)]*)\)/gu;
+
+/**
+ * Recorta espacios con la misma semántica que `str.strip()` de Python.
+ * @param {string} value
+ * @returns {string}
+ */
+export function pyStrip(value) {
+  return value.replace(PY_STRIP_RE, "");
+}
+
+/**
+ * Divide un texto por los mismos separadores que `str.splitlines()` de Python,
+ * sin conservar los saltos y sin añadir una línea vacía final.
+ * @param {string} text
+ * @returns {string[]}
+ */
+export function splitLines(text) {
+  if (text === "") {
+    return [];
+  }
+
+  const lines = [];
+  let start = 0;
+  for (const match of text.matchAll(PY_LINE_BREAK_RE)) {
+    lines.push(text.slice(start, match.index));
+    start = match.index + match[0].length;
+  }
+  if (start < text.length) {
+    lines.push(text.slice(start));
+  }
+  return lines;
+}
+
+/**
+ * Compara dos cadenas por code point Unicode, como `sorted()` de Python.
+ * @param {string} left
+ * @param {string} right
+ * @returns {number}
+ */
+export function compareCodePoints(left, right) {
+  let leftIndex = 0;
+  let rightIndex = 0;
+
+  while (leftIndex < left.length && rightIndex < right.length) {
+    const leftPoint = left.codePointAt(leftIndex);
+    const rightPoint = right.codePointAt(rightIndex);
+    if (leftPoint !== rightPoint) {
+      return leftPoint - rightPoint;
+    }
+    leftIndex += leftPoint > MAX_BMP_CODE_POINT ? 2 : 1;
+    rightIndex += rightPoint > MAX_BMP_CODE_POINT ? 2 : 1;
+  }
+
+  return left.length - leftIndex - (right.length - rightIndex);
+}
+
+/**
+ * Ordena cadenas por code point sin depender del orden de `readdir`.
+ * @param {string[]} entries
+ * @returns {string[]}
+ */
+export function sortByCodePoint(entries) {
+  return [...entries].sort(compareCodePoints);
+}
+
+/**
+ * Descompone una ruta en los componentes que compara `pathlib.Path`: la raíz
+ * cuenta como primer componente y los separadores repetidos no crean vacíos.
+ * @param {string} value
+ * @returns {string[]}
+ */
+function pathParts(value) {
+  const root = path.parse(value).root;
+  const rest = value.slice(root.length).split(path.sep).filter(Boolean);
+  return root === "" ? rest : [root, ...rest];
+}
+
+/**
+ * Compara dos rutas componente a componente, como `sorted(Path(...))` de Python.
+ * @param {string} left
+ * @param {string} right
+ * @returns {number}
+ */
+export function comparePathComponents(left, right) {
+  const leftParts = pathParts(left);
+  const rightParts = pathParts(right);
+  const limit = Math.min(leftParts.length, rightParts.length);
+
+  for (let index = 0; index < limit; index += 1) {
+    const result = compareCodePoints(leftParts[index], rightParts[index]);
+    if (result !== 0) {
+      return result;
+    }
+  }
+
+  return leftParts.length - rightParts.length;
+}
+
+/**
+ * Resuelve una ruta como `Path.resolve()` de Python: sigue symlinks componente a
+ * componente y, si un componente no existe, conserva el resto sin resolver.
+ * @param {string} input
+ * @returns {string}
+ */
+export function resolvePath(input) {
+  const absolute = path.isAbsolute(input) ? input : path.resolve(input);
+  const root = path.parse(absolute).root;
+  const state = {
+    pending: absolute.slice(root.length).split(path.sep),
+    resolved: root,
+    seen: new Set(),
+  };
+
+  while (state.pending.length > 0) {
+    resolveNext(state);
+  }
+
+  return state.resolved;
+}
+
+/**
+ * Resuelve el siguiente componente pendiente, siguiendo un symlink si lo hay.
+ * @param {{ pending: string[], resolved: string, seen: Set<string> }} state
+ * @returns {void}
+ */
+function resolveNext(state) {
+  const name = state.pending.shift();
+  if (!name || name === ".") {
+    return;
+  }
+  if (name === "..") {
+    state.resolved = path.dirname(state.resolved);
+    return;
+  }
+
+  const candidate = path.join(state.resolved, name);
+  const stats = lstatOrNull(candidate);
+  if (!stats || !stats.isSymbolicLink()) {
+    state.resolved = candidate;
+    return;
+  }
+
+  followSymlink(state, candidate);
+}
+
+/**
+ * Lee `lstat` sin lanzar: un componente inexistente se conserva como texto.
+ * @param {string} candidate
+ * @returns {import("node:fs").Stats | null}
+ */
+function lstatOrNull(candidate) {
+  try {
+    return lstatSync(candidate);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Sustituye el symlink pendiente por su destino; un ciclo conserva la parte
+ * resuelta y deja el resto sin resolver, como `Path.resolve()`.
+ * @param {{ pending: string[], resolved: string, seen: Set<string> }} state
+ * @param {string} candidate
+ * @returns {void}
+ */
+function followSymlink(state, candidate) {
+  if (state.seen.has(candidate)) {
+    state.resolved = path.resolve(candidate, ...state.pending);
+    state.pending = [];
+    return;
+  }
+  state.seen.add(candidate);
+
+  const linkTarget = readlinkSync(candidate);
+  if (!path.isAbsolute(linkTarget)) {
+    state.pending.unshift(...linkTarget.split(path.sep));
+    return;
+  }
+
+  const root = path.parse(linkTarget).root;
+  state.resolved = root;
+  state.pending.unshift(...linkTarget.slice(root.length).split(path.sep));
+}
+
+/**
+ * Junta un directorio y una ruta relativa sin normalizar `.` ni `..`, para que
+ * `resolvePath()` los procese con la misma semántica que Python.
+ * @param {string} directory
+ * @param {string} relative
+ * @returns {string}
+ */
+export function joinUnnormalized(directory, relative) {
+  return path.isAbsolute(relative)
+    ? relative
+    : `${directory}${path.sep}${relative}`;
+}
+
+/**
+ * Lee un ADR con la misma traducción de saltos que el modo texto de Python:
+ * `\r\n` y `\r` se convierten en `\n` antes de aplicar las reglas.
+ * @param {string} file
+ * @returns {string}
+ */
+export function readText(file) {
+  return readFileSync(file, "utf8").replace(/\r\n?/g, "\n");
+}

package/scripts/ensure-bin-exec.mjs

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+/**
+ * Asegura que el CLI y el gate de ADRs se publiquen con bit de ejecución.
+ *
+ * El blob de git solo distingue ejecutable / no ejecutable, y `npm pack`
+ * conserva ese modo: un binario en 100644 produce un tarball que algunos
+ * gestores de paquetes no reparan. Se ejecuta en `prepack` para que el
+ * artefacto sea correcto por sí mismo (A-007, A-052 §4).
+ *
+ * En Windows el modo POSIX no aplica: el script es un no-op.
+ */
+import { chmodSync } from "node:fs";
+
+const EXECUTABLES = ["bin/cli.js", "scripts/verify-adr-consistency.mjs"];
+const EXECUTABLE_MODE = 0o755;
+
+if (process.platform !== "win32") {
+  for (const executable of EXECUTABLES) {
+    chmodSync(executable, EXECUTABLE_MODE);
+  }
+}

package/scripts/verify-adr-consistency.mjs

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+/**
+ * Gate de consistencia del registro ADR (ADR-0000).
+ *
+ * Valida cinco reglas y sale con código 0 solo si no hay violaciones:
+ *   - jerarquia    los ADRs no referencian tiers prohibidos (A solo cita A; T cita A y T;
+ *                  P cita A y P). Detecta tanto enlaces markdown como citas en texto plano a
+ *                  IDs `<PREFIJO>-NNN`: una cita con un prefijo no permitido para el tier —o
+ *                  con cualquier otro prefijo, incluidos G y PJ— es una violación, porque
+ *                  ningún ADR A/T/P referencia el tier de proyecto. Una misma referencia
+ *                  prohibida se reporta una sola vez aunque aparezca como enlace y como ID.
+ *   - enlaces      todos los enlaces markdown internos (relativos, *.md) resuelven a un
+ *                  archivo existente.
+ *   - frontmatter  el título H1 sigue `# <TIER>-<NNN>: Título` y los campos `originally` /
+ *                  `Enriquecido desde` usan la ortografía exacta.
+ *   - indices      cada ADR aparece en el índice de su tier y el índice no lista ADRs
+ *                  inexistentes.
+ *   - hardcoded    los ADRs activos no duplican listas cuya fuente canónica vive en el
+ *                  paquete (skills → @imolko/ultra-agent) ni en docs/agents/ (punteros).
+ *
+ * El gate resuelve su raíz desde su propia ubicación, no desde `process.cwd()`: se ejecuta
+ * contra el registro del repositorio que lo contiene. La implementación vive en
+ * `scripts/adr-gate/` para respetar las métricas de A-046; este archivo solo orquesta.
+ *
+ * Uso: node scripts/verify-adr-consistency.mjs
+ */
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { createRegistry } from "./adr-gate/registry.mjs";
+import { createReport } from "./adr-gate/report.mjs";
+import { ruleEnlaces } from "./adr-gate/rules/enlaces.mjs";
+import { ruleFrontmatter } from "./adr-gate/rules/frontmatter.mjs";
+import { ruleHardcoded } from "./adr-gate/rules/hardcoded.mjs";
+import { ruleIndices } from "./adr-gate/rules/indices.mjs";
+import { ruleJerarquia } from "./adr-gate/rules/jerarquia.mjs";
+import { resolvePath } from "./adr-gate/text.mjs";
+
+const SCRIPT_PATH = fileURLToPath(import.meta.url);
+const ROOT = path.dirname(path.dirname(resolvePath(SCRIPT_PATH)));
+
+/**
+ * Ejecuta las cinco reglas en el orden del gate original y emite el resultado:
+ * violaciones por stderr con exit 1, o el resumen limpio por stdout con exit 0.
+ * @returns {number} código de salida
+ */
+function main() {
+  const registry = createRegistry(ROOT);
+  const report = createReport();
+
+  ruleJerarquia(registry, report);
+  ruleEnlaces(registry, report);
+  ruleFrontmatter(registry, report);
+  ruleIndices(registry, report);
+  ruleHardcoded(registry, report);
+
+  if (report.violations.length > 0) {
+    for (const violation of report.violations) {
+      process.stderr.write(`${violation}\n`);
+    }
+    process.stderr.write(
+      `${report.violations.length} violación(es) en el registro ADR.\n`,
+    );
+    return 1;
+  }
+
+  process.stdout.write("Registro ADR consistente: 0 violaciones.\n");
+  return 0;
+}
+
+process.exitCode = main();

package/skills/writing-for-agents/references/adrs.md

@@ -6,7 +6,7 @@ The format, tier hierarchy, tag vocabulary, and lifecycle are owned by `<adr_dir
 
 ## The levers, instantiated
 
-- **Checkable, exhaustive completion criterion.** The gate `scripts/verify-adr-consistency.py` must exit `0` with zero violations. "Done" is a binary, machine-checked state — not a vague "understanding reached". This is the completion-criterion lever from `SKILL.md`, applied to a whole document family.
+- **Checkable, exhaustive completion criterion.** The gate `scripts/verify-adr-consistency.mjs` must exit `0` with zero violations. "Done" is a binary, machine-checked state — not a vague "understanding reached". This is the completion-criterion lever from `SKILL.md`, applied to a whole document family.
 - **Environment as source of truth (the cache rule).** The gate's `hardcoded` rule *is* the cache principle, enforced by machine.
 - **Single source of truth.** `<adr_dir>/index.md` is the canonical index, enforced by the `indices` gate rule.
 - **Context pointers.** `<adr_dir>/index.md` names each ADR and its tier — a real pointer hub doing both jobs (states what the material is, encodes when to reach it). Each tier's `index.md` is the same object one level down.
@@ -15,5 +15,5 @@ The format, tier hierarchy, tag vocabulary, and lifecycle are owned by `<adr_dir
 ## When writing an ADR
 
 - Follow `ADR-0000` exactly: Nygard sections, the project frontmatter, the tier matching the decision's scope, the approved tag vocabulary, the numbering and lifecycle rules.
-- Run the gate before finishing: `python3 scripts/verify-adr-consistency.py`. Exit `0` is the completion criterion.
+- Run the gate before finishing: `node scripts/verify-adr-consistency.mjs`. Exit `0` is the completion criterion.
 - Link related ADRs by relative markdown path (the `jerarquia` and `enlaces` gate rules check this); point at them, don't restate them.

package/scripts/verify-adr-consistency.py

@@ -1,250 +0,0 @@
-#!/usr/bin/env python3
-"""Gate de consistencia del registro ADR (ADR-0000).
-
-Valida cinco reglas y sale con código 0 solo si no hay violaciones:
-  - jerarquia    los ADRs no referencian tiers prohibidos (A solo cita A; T cita A y T;
-                 P cita A y P). Detecta tanto enlaces markdown como citas en texto plano a
-                 IDs `<PREFIJO>-NNN`: una cita con un prefijo no permitido para el tier —o
-                 con cualquier otro prefijo, incluidos G y PJ— es una violación, porque
-                 ningún ADR A/T/P referencia el tier de proyecto. Una misma referencia
-                 prohibida se reporta una sola vez aunque aparezca como enlace y como ID.
-  - enlaces      todos los enlaces markdown internos (relativos, *.md) resuelven a un
-                 archivo existente.
-  - frontmatter  el título H1 sigue `# <TIER>-<NNN>: Título` y los campos `originally` /
-                 `Enriquecido desde` usan la ortografía exacta.
-  - indices      cada ADR aparece en el índice de su tier y el índice no lista ADRs
-                 inexistentes.
-  - hardcoded    los ADRs activos no duplican listas cuya fuente canónica vive en el
-                 paquete (skills → @imolko/ultra-agent) ni en docs/agents/ (punteros).
-
-Uso: python3 scripts/verify-adr-consistency.py
-"""
-
-import re
-import sys
-from pathlib import Path
-
-ROOT = Path(__file__).resolve().parent.parent
-ADR_DIR = ROOT / "docs" / "adr"
-
-TIER_DIRS = {
-    "A": ADR_DIR / "foundational",
-    "T": ADR_DIR / "typescript",
-    "P": ADR_DIR / "python",
-}
-
-H1_RE = re.compile(r"^# (A|T|P)-\d{3}: .+")
-ORIGINALLY_RE = re.compile(r"^\*\*originally\*\*:", flags=re.MULTILINE)
-ORIGINALLY_WRONG_RE = re.compile(r"^\*\*[Oo]riginally\*\*:", flags=re.MULTILINE)
-ENRICHED_RE = re.compile(r"^\*\*Enriquecido desde\*\*:", flags=re.MULTILINE)
-ENRICHED_WRONG_RE = re.compile(r"^\*\*[Ee]nriquecido [Dd]esde\*\*:", flags=re.MULTILINE)
-
-# Anchors caducados: la fuente canónica de los skills pasó al paquete y el hub de
-# punteros pasó a docs/agents/ (A-052). Un ADR activo no debe repetirlos.
-STALE_ANCHORS = (".pi/skills/", ".pi/repo-config.md")
-
-violations = []
-
-
-def report(rule: str, message: str) -> None:
-    violations.append(f"[{rule}] {message}")
-
-
-def is_active_adr(text: str) -> bool:
-    match = re.search(r"^\*\*Estado\*\*: ?(.+)$", text, flags=re.MULTILINE)
-    if not match:
-        return True
-    state = match.group(1).strip()
-    return state not in ("Reemplazado", "Deprecado")
-
-
-def tier_adr_files(tier: str):
-    return sorted(TIER_DIRS[tier].glob(f"{tier}-*.md"))
-
-
-def link_targets(text: str):
-    """Devuelve los destinos de los enlaces markdown inline `](dest)`. """
-    return re.findall(r"\]\(([^)]+)\)", text)
-
-
-def resolve_link(adir_file: Path, target: str):
-    """Resuelve un target de enlace relativo contra el directorio del ADR."""
-    target = target.strip()
-    if target.startswith(("<", ">")) or "://" in target or target.startswith("#"):
-        return None  # URL externa, autolink o ancla pura — fuera del gate
-    # Ignorar fragmentos (#ancla)
-    target = target.split("#", 1)[0]
-    if not target:
-        return None
-    if not target.endswith(".md"):
-        return None
-    return (adir_file.parent / target).resolve()
-
-
-def target_tier(resolved: Path):
-    """Clasifica un archivo resuelto en su tier (o None si está fuera del registro)."""
-    try:
-        rel = resolved.relative_to(ADR_DIR)
-    except ValueError:
-        return None
-    parts = rel.parts
-    if len(parts) >= 2:
-        if parts[0] == "foundational":
-            return "A"
-        if parts[0] == "typescript":
-            return "T"
-        if parts[0] == "python":
-            return "P"
-    if rel.name.startswith("ADR-0000") or rel.name == "index.md":
-        return "meta"
-    return "project"
-
-
-ALLOWED_TARGETS = {
-    "A": {"A", "meta"},
-    "T": {"A", "T", "meta"},
-    "P": {"A", "P", "meta"},
-}
-
-# Citas en texto plano a un ID de ADR. Una a dos letras mayúsculas evita falsos
-# positivos con identificadores de tres letras (ISO-8601, RFC-2119, SHA-256).
-PLAIN_ID_RE = re.compile(r"\b([A-Z]{1,2})-\d{3}\b")
-
-# Destino de un enlace markdown inline `](destino)`. Se elimina antes del escaneo
-# de texto plano para que una referencia no se reporte también como cita.
-LINK_TARGET_RE = re.compile(r"\]\([^)]*\)")
-
-# Enlace markdown inline completo: etiqueta y destino. La etiqueta puede citar el
-# ID cuando el destino no lo contiene (p. ej. `[T-001](../typescript/index.md)`).
-LINK_RE = re.compile(r"\[([^\]]*)\]\(([^)]*)\)")
-
-
-def rule_jerarquia() -> None:
-    for tier, allowed in ALLOWED_TARGETS.items():
-        allowed_prefixes = {t for t in allowed if t in TIER_DIRS}
-        for adr in tier_adr_files(tier):
-            text = adr.read_text(encoding="utf-8")
-            reported_ids = set()
-
-            for label, target in LINK_RE.findall(text):
-                resolved = resolve_link(adr, target)
-                if resolved is None:
-                    continue
-                resolved_tier = target_tier(resolved)
-                if resolved_tier is None or resolved_tier in allowed:
-                    continue
-                # Los IDs citados por el enlace —en la etiqueta o en el destino—
-                # quedan cubiertos por esta violación y no se reportan otra vez.
-                for match in PLAIN_ID_RE.finditer(f"{label} {target}"):
-                    reported_ids.add(match.group(0))
-                report(
-                    "jerarquia",
-                    f"{adr.relative_to(ROOT)} referencia al tier {resolved_tier} ({target}), prohibido para el tier {tier}",
-                )
-
-            plain_text = LINK_TARGET_RE.sub("", text)
-            for match in PLAIN_ID_RE.finditer(plain_text):
-                prefix, ident = match.group(1), match.group(0)
-                if prefix in allowed_prefixes or ident in reported_ids:
-                    continue
-                reported_ids.add(ident)
-                report(
-                    "jerarquia",
-                    f"{adr.relative_to(ROOT)} cita en texto plano {ident} (prefijo {prefix}), prohibido para el tier {tier}",
-                )
-
-
-def rule_enlaces() -> None:
-    for md in sorted(ADR_DIR.rglob("*.md")):
-        text = md.read_text(encoding="utf-8")
-        for target in link_targets(text):
-            resolved = resolve_link(md, target)
-            if resolved is None:
-                continue
-            if not resolved.exists():
-                report("enlaces", f"{md.relative_to(ROOT)} enlaza a un archivo inexistente: {target}")
-
-
-def rule_frontmatter() -> None:
-    for tier in ("A", "T", "P"):
-        for adr in tier_adr_files(tier):
-            text = adr.read_text(encoding="utf-8")
-            rel = adr.relative_to(ROOT)
-
-            first_line = text.splitlines()[0] if text.splitlines() else ""
-            if not H1_RE.match(first_line):
-                report("frontmatter", f"{rel}: el título H1 no sigue `# <TIER>-<NNN>: Título`")
-
-            if not ORIGINALLY_RE.search(text):
-                report("frontmatter", f"{rel}: falta el campo `**originally**:` (minúsculas)")
-
-            # Detectar ortografía incorrecta del campo
-            for line in text.splitlines():
-                stripped = line.strip()
-                if ORIGINALLY_WRONG_RE.match(stripped) and not ORIGINALLY_RE.match(stripped):
-                    report("frontmatter", f"{rel}: `originally` debe ir en minúsculas")
-                    break
-
-            for line in text.splitlines():
-                stripped = line.strip()
-                if ENRICHED_WRONG_RE.match(stripped) and not ENRICHED_RE.match(stripped):
-                    report("frontmatter", f"{rel}: el campo opcional debe escribirse `**Enriquecido desde**:`")
-                    break
-
-
-def rule_indices() -> None:
-    for tier in ("A", "T", "P"):
-        index = TIER_DIRS[tier] / "index.md"
-        if not index.exists():
-            report("indices", f"falta el índice del tier {tier}: {index.relative_to(ROOT)}")
-            continue
-
-        index_text = index.read_text(encoding="utf-8")
-        # Enlaces dentro del tier (`./<nombre>.md`)
-        index_targets = {t for t in link_targets(index_text) if t.startswith("./") and t.endswith(".md")}
-
-        adr_files = tier_adr_files(tier)
-        for adr in adr_files:
-            target = f"./{adr.name}"
-            if target not in index_targets:
-                report("indices", f"{adr.relative_to(ROOT)} no aparece en el índice de su tier")
-
-        for target in index_targets:
-            resolved = (TIER_DIRS[tier] / target[2:]).resolve()
-            if not resolved.exists():
-                report("indices", f"el índice {index.relative_to(ROOT)} lista un ADR inexistente: {target}")
-
-
-def rule_hardcoded() -> None:
-    for tier in ("A", "T", "P"):
-        for adr in tier_adr_files(tier):
-            text = adr.read_text(encoding="utf-8")
-            if not is_active_adr(text):
-                continue
-            for anchor in STALE_ANCHORS:
-                if anchor in text:
-                    report(
-                        "hardcoded",
-                        f"{adr.relative_to(ROOT)} duplica el ancla caducada `{anchor}` (fuente canónica: paquete/docs/agents)",
-                    )
-
-
-def main() -> int:
-    rule_jerarquia()
-    rule_enlaces()
-    rule_frontmatter()
-    rule_indices()
-    rule_hardcoded()
-
-    if violations:
-        for v in violations:
-            print(v, file=sys.stderr)
-        print(f"{len(violations)} violación(es) en el registro ADR.", file=sys.stderr)
-        return 1
-
-    print("Registro ADR consistente: 0 violaciones.")
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())