feat(papers): estructura, scaffolding y capability page del artefacto papers/

Nuevo tipo de artefacto para papers académicos reproducibles (papers/<NNNN-slug>/): - Plantillas docs/templates/paper.md (IMRaD completo con guías por sección: Abstract, Introduction, Related work, Methods, Results, Discussion con Limitaciones + Amenazas a la validez, Conclusion + Future work) y docs/templates/preregistration.md (H0/H1 falsable, variables, diseño, plan de análisis con test exacto + effect size + corrección múltiple, predicción cuantitativa; nota anti-HARKing de congelado). - Pipeline init_paper (bash/functions/pipelines/init_paper.sh + .md): calcula el siguiente NNNN, crea las subcarpetas (experiments data figures reviews out), copia las plantillas rellenando el frontmatter (title, slug, date, phase=question, status=draft) y crea references.md. No hace git init (fase interna local). - Función atómica reutilizable next_numbered_dir (bash/functions/io): siguiente prefijo NNNN- escaneando un directorio numerado (reutilizable por papers/reports/issues). - papers/ como artefacto local gitignored (bloque en .gitignore + papers/.gitkeep): un paper en fase interna no contamina el repo padre; al promocionar a publishable se vuelve sub-repo Gitea propio. - Página de capacidad docs/capabilities/papers.md + fila en el INDEX: tabla de funciones del grupo papers (disponibles + en construcción por la flota), ejemplo canónico end-to-end y fronteras. Reutiliza slugify_ascii del registry. Diseño: reports/0001-2026-06-30-papers-system-design.md. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
2026-06-30 20:38:38 +02:00
23 changed files with 614 additions and 1265 deletions
@@ -54,6 +54,13 @@ reports/*
 !reports/.gitkeep
 projects/*/reports/

+# Papers — artefacto local: papers académicos reproducibles. En fase interna viven
+# local y gitignored (como los reports); al promocionar a fase publishable se
+# vuelven sub-repo Gitea propio (como apps/analyses). Solo el marcador .gitkeep se
+# versiona. Convención: docs/capabilities/papers.md
+papers/*
+!papers/.gitkeep
+
 # Node / pnpm
 **/node_modules/

@@ -0,0 +1,58 @@
+---
+name: next_numbered_dir
+kind: function
+lang: bash
+domain: io
+version: "1.0.0"
+purity: impure
+signature: "next_numbered_dir(parent_dir: string, [width: int]) -> string"
+description: "Calcula el siguiente prefijo numerico NNNN- para un directorio numerado incremental. Escanea los subdirectorios directos de parent_dir cuyo nombre empiece por NNNN- (4+ digitos seguidos de guion), toma el maximo, le suma 1 y lo imprime con zero-padding al ancho width (default 4). Si parent_dir no existe o no tiene subdirs que matcheen, imprime 0001."
+tags: [papers, io, scaffold]
+uses_functions: []
+uses_types: []
+returns: []
+returns_optional: false
+error_type: "error_go_core"
+imports: []
+params:
+  - name: parent_dir
+    desc: "directorio padre cuyos subdirectorios numerados (NNNN-...) se escanean; obligatorio"
+  - name: width
+    desc: "ancho del zero-padding del numero impreso (default 4); opcional"
+output: "el siguiente numero como string con zero-padding a width digitos a stdout (ej. 0003); usage a stderr y exit 1 si falta parent_dir"
+tested: false
+tests: []
+test_file_path: ""
+file_path: "bash/functions/io/next_numbered_dir.sh"
+---
+
+## Ejemplo
+
+```bash
+source bash/functions/io/next_numbered_dir.sh
+
+# Sobre un papers/ que ya contiene 0001-foo y 0002-bar
+mkdir -p /tmp/papers/{0001-foo,0002-bar}
+next_numbered_dir /tmp/papers
+# -> 0003
+
+# Directorio vacio o inexistente -> primer numero
+next_numbered_dir /tmp/papers_nuevo
+# -> 0001
+
+# Ancho de padding distinto
+next_numbered_dir /tmp/papers 6
+# -> 000003
+```
+
+## Cuando usarla
+
+Cuando scaffoldees un artefacto numerado incremental (papers/, reports/, issues/) y necesites el siguiente NNNN sin colision: escanea lo que ya existe en disco y te da el numero libre listo para crear `<NNNN>-<slug>`.
+
+## Gotchas
+
+- **Impura**: lee el filesystem (estado del directorio en el momento de la llamada). No crea nada — solo calcula e imprime el numero.
+- **Octal**: los numeros con cero a la izquierda (`08`, `09`) se interpretan como octal en aritmetica bash y romperian el calculo. La funcion fuerza base 10 con `10#$num` para evitarlo.
+- **Solo subdirectorios**: cuenta unicamente subdirs directos. Archivos sueltos (`.gitkeep`, `notas.md`) y subdirs que no matcheen el patron se ignoran. No es recursivo.
+- **Patron estricto**: el prefijo debe ser `NNNN-` (minimo 4 digitos seguidos de guion). Un subdir `12-foo` o `0001foo` (sin guion) NO se cuenta.
+- No hay deteccion de huecos: devuelve `max+1`, no el primer numero libre intermedio. Si tienes `0001` y `0003`, devuelve `0004`, no `0002`.
@@ -0,0 +1,46 @@
+#!/usr/bin/env bash
+# next_numbered_dir — Compute the next NNNN- prefix for a numbered directory.
+#
+# Scans the DIRECT subdirectories of <parent_dir> whose names start with a
+# numeric prefix of the form `NNNN-` (4+ digits followed by a hyphen), takes
+# the maximum number, adds 1, and prints it zero-padded to <width> (default 4).
+# If <parent_dir> does not exist or contains no matching subdir, prints the
+# first number (0001 at default width).
+
+next_numbered_dir() {
+    local parent_dir="${1:-}"
+    local width="${2:-4}"
+
+    if [[ -z "$parent_dir" ]]; then
+        echo "usage: next_numbered_dir <parent_dir> [width]" >&2
+        return 1
+    fi
+
+    local max=0
+    local entry base num
+
+    if [[ -d "$parent_dir" ]]; then
+        # Iterate only over direct subdirectories. The trailing slash in the
+        # glob ensures files (e.g. .gitkeep) are skipped — only dirs match.
+        for entry in "$parent_dir"/*/; do
+            # If the glob matched nothing it stays literal; guard with -d.
+            [[ -d "$entry" ]] || continue
+            base="$(basename "$entry")"
+            # Require a prefix of 4+ digits followed by a hyphen.
+            if [[ "$base" =~ ^([0-9]{4,})- ]]; then
+                num="${BASH_REMATCH[1]}"
+                # Force base 10 so leading zeros (08, 09) are not read as octal.
+                num=$((10#$num))
+                if (( num > max )); then
+                    max=$num
+                fi
+            fi
+        done
+    fi
+
+    printf "%0*d\n" "$width" $(( max + 1 ))
+}
+
+if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
+    next_numbered_dir "$@"
+fi
@@ -0,0 +1,69 @@
+---
+name: init_paper
+kind: pipeline
+lang: bash
+domain: pipelines
+version: "1.0.0"
+purity: impure
+signature: "init_paper(slug: string, [--title <t>] [--domain <d>] [--tags <csv>]) -> void"
+description: "Scaffold de un paper académico reproducible en papers/<NNNN-slug>/. Calcula el siguiente número incremental escaneando papers/, crea las subcarpetas (experiments data figures reviews out), copia las plantillas paper.md (IMRaD) + preregistration.md (anti-HARKing) rellenando el frontmatter (title, slug, date de hoy, phase=question, status=draft) y crea references.md. NO hace git init: el paper arranca en fase interna local (papers/ gitignored). Grupo de capacidad papers."
+tags: [papers, scaffold, paper, pipeline, bash, launcher]
+uses_functions:
+  - next_numbered_dir_bash_io
+  - slugify_ascii_py_core
+uses_types: []
+returns: []
+returns_optional: false
+error_type: "error_go_core"
+imports: []
+params:
+  - name: slug
+    desc: "identificador legible del paper; se slugifica a ASCII (espacios/acentos se normalizan) y se prefija con el siguiente NNNN incremental"
+  - name: "--title"
+    desc: "título del paper (string); si se omite, usa el slug limpio. No debe contener el carácter '|'"
+  - name: "--domain"
+    desc: "dominio del paper escrito en el frontmatter (default datascience)"
+  - name: "--tags"
+    desc: "tags CSV que se escriben en el frontmatter de paper.md (opcional)"
+output: "sin salida directa; crea papers/<NNNN-slug>/ con paper.md, preregistration.md, references.md y las subcarpetas experiments/ data/ figures/ reviews/ out/. Imprime el resumen y los pasos siguientes a stdout."
+tested: false
+tests: []
+test_file_path: ""
+file_path: "bash/functions/pipelines/init_paper.sh"
+---
+
+## Ejemplo
+
+```bash
+# Scaffold de un paper nuevo (numera 0001, 0002, ... automáticamente)
+fn run init_paper mi-primer-paper --title "Mi primer paper"
+fn run init_paper reactive-loop-calls --domain datascience --tags registry,telemetria
+
+# El slug se slugifica: "Áreas de Mejora" -> papers/0003-areas-de-mejora/
+fn run init_paper "Áreas de Mejora"
+```
+
+## Cuando usarla
+
+Cuando empiezas un paper académico nuevo dentro de `fn_registry` y necesitas el esqueleto del artefacto (`papers/<NNNN-slug>/`) con las plantillas IMRaD y de pre-registro listas para rellenar. Es el paso 1 del grupo de capacidad `papers` (ver `docs/capabilities/papers.md`), antes de la revisión de literatura y del pre-registro de la hipótesis.
+
+## Flujo
+
+1. Parsea `<slug>` (posicional) + flags `--title` / `--domain` / `--tags`. Falla con exit ≠ 0 si falta el slug.
+2. `slugify_ascii` — normaliza el slug a ASCII lowercase sin diacríticos (reutiliza la función del registry, solo stdlib).
+3. `next_numbered_dir papers/` — calcula el siguiente NNNN de 4 dígitos sin colisión.
+4. Crea `papers/<NNNN-slug>/` con las subcarpetas `experiments/ data/ figures/ reviews/ out/`.
+5. Copia `docs/templates/paper.md` + `docs/templates/preregistration.md` y rellena el frontmatter por clave de línea (title, slug, date de hoy, domain, tags; phase=question y status=draft vienen de la plantilla).
+6. Crea `references.md` vacío.
+
+## Gotchas
+
+- **NO hace `git init`.** El paper arranca en fase interna local; `papers/` está gitignored en el repo padre (solo `papers/.gitkeep` se versiona). Promocionar a sub-repo Gitea (fase publishable) es manual.
+- **El `--title` no debe contener el carácter `|`** (se usa como delimitador de sed al rellenar el frontmatter; los `&` y `\` sí se escapan).
+- **No indexa el paper en `registry.db`** — los artefactos `papers/<slug>/` no se indexan en esta fase (KISS); sí se indexa este pipeline.
+- Requiere `python3` (del venv del registry o del sistema) para slugificar; `slugify_ascii` solo usa stdlib, así que el venv no es obligatorio.
+- Idempotencia: si el directorio destino ya existiera, aborta con exit ≠ 0 en vez de sobrescribir.
+
+## Notas
+
+Cada paper es un artefacto independiente (mismo patrón que `apps/` y `analysis/`, pero para investigación). El pipeline usa `set -euo pipefail`: cualquier fallo detiene la ejecución. Parte del grupo de capacidad `papers` — diseño completo en `reports/0001-2026-06-30-papers-system-design.md`.
@@ -0,0 +1,177 @@
+#!/usr/bin/env bash
+# init_paper
+# ----------
+# Scaffold de un paper académico reproducible en papers/<NNNN-slug>/.
+#
+# Calcula el siguiente número incremental escaneando papers/, crea el
+# directorio con todas las subcarpetas (experiments data figures reviews out),
+# copia las plantillas paper.md + preregistration.md rellenando el frontmatter
+# (title, slug, date de hoy, phase=question, status=draft) y crea references.md.
+#
+# NO hace `git init`: el paper arranca en fase interna local (papers/ está
+# gitignored en el repo padre, solo .gitkeep se versiona). La promoción a
+# sub-repo Gitea (fase publishable) es un paso posterior MANUAL.
+#
+# Compone: next_numbered_dir (helper de numeración del registry) +
+#          slugify_ascii (slug ASCII del registry).
+#
+# USO:
+#   ./init_paper.sh <slug> [--title "..."] [--domain <d>] [--tags a,b,c]
+#
+# EJEMPLOS:
+#   ./init_paper.sh mi-primer-paper --title "Mi primer paper"
+#   ./init_paper.sh reactive-loop-calls --domain datascience --tags registry,telemetria
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+REGISTRY_ROOT="$(cd "$SCRIPT_DIR/../../.." && pwd)"
+
+# Funciones atómicas del registry
+source "$REGISTRY_ROOT/bash/functions/io/next_numbered_dir.sh"
+
+# ── Parsing de argumentos ────────────────────────────────────
+
+SLUG_RAW=""
+TITLE=""
+DOMAIN="datascience"
+TAGS=""
+
+while [ $# -gt 0 ]; do
+    case "$1" in
+        --title)
+            TITLE="$2"; shift 2 ;;
+        --domain)
+            DOMAIN="$2"; shift 2 ;;
+        --tags)
+            TAGS="$2"; shift 2 ;;
+        -h|--help)
+            grep "^#" "$0" | sed 's/^# \?//' ; exit 0 ;;
+        -*)
+            echo "Flag desconocido: $1" >&2 ; exit 1 ;;
+        *)
+            if [ -z "$SLUG_RAW" ]; then
+                SLUG_RAW="$1"
+            else
+                echo "ERROR: argumento posicional inesperado: '$1' (solo se admite un <slug>)." >&2
+                exit 1
+            fi
+            shift ;;
+    esac
+done
+
+if [ -z "$SLUG_RAW" ]; then
+    echo "ERROR: falta el argumento <slug>." >&2
+    echo "Uso: $0 <slug> [--title \"...\"] [--domain <d>] [--tags a,b,c]" >&2
+    echo "  Ejemplo: $0 mi-primer-paper --title \"Mi primer paper\"" >&2
+    exit 1
+fi
+
+# ── Slugificar (reutiliza slugify_ascii del registry; solo stdlib) ──
+
+PYBIN="$REGISTRY_ROOT/python/.venv/bin/python3"
+[ -x "$PYBIN" ] || PYBIN="$(command -v python3 || true)"
+if [ -z "$PYBIN" ]; then
+    echo "ERROR: no se encontró python3 para slugificar el slug." >&2
+    exit 1
+fi
+
+SLUG_CLEAN=$("$PYBIN" -c '
+import sys, os
+sys.path.insert(0, os.path.join(sys.argv[2], "python", "functions"))
+from core.slugify_ascii import slugify_ascii
+print(slugify_ascii(sys.argv[1], default="paper"))
+' "$SLUG_RAW" "$REGISTRY_ROOT")
+
+# ── Resolver número incremental y directorio destino ─────────
+
+PAPERS_DIR="$REGISTRY_ROOT/papers"
+mkdir -p "$PAPERS_DIR"
+
+NUM=$(next_numbered_dir "$PAPERS_DIR")
+SLUG_FULL="${NUM}-${SLUG_CLEAN}"
+PAPER_DIR="$PAPERS_DIR/$SLUG_FULL"
+
+if [ -d "$PAPER_DIR" ]; then
+    echo "ERROR: el directorio del paper ya existe: $PAPER_DIR" >&2
+    exit 1
+fi
+
+TODAY=$(date +%Y-%m-%d)
+[ -n "$TITLE" ] || TITLE="$SLUG_CLEAN"
+
+TAGS_YAML="[]"
+if [ -n "$TAGS" ]; then
+    TAGS_YAML="[$(echo "$TAGS" | sed 's/,/, /g')]"
+fi
+
+echo ""
+echo "════════════════════════════════════════════════════════════"
+echo "  INIT PAPER: ${SLUG_FULL}"
+echo "  Título:     ${TITLE}"
+echo "  Directorio: ${PAPER_DIR}"
+echo "════════════════════════════════════════════════════════════"
+echo ""
+
+# ── Crear estructura ─────────────────────────────────────────
+
+echo "[1/3] Creando estructura..."
+mkdir -p "$PAPER_DIR"/experiments "$PAPER_DIR"/data "$PAPER_DIR"/figures \
+         "$PAPER_DIR"/reviews "$PAPER_DIR"/out
+echo "  experiments/ data/ figures/ reviews/ out/"
+
+# ── Copiar plantillas + rellenar frontmatter ─────────────────
+
+echo "[2/3] Escribiendo paper.md + preregistration.md..."
+
+# Escapa caracteres especiales del RHS de sed (delimitador |)
+sed_escape() { printf '%s' "$1" | sed -e 's/[\\&|]/\\&/g'; }
+TITLE_ESC="$(sed_escape "$TITLE")"
+DOMAIN_ESC="$(sed_escape "$DOMAIN")"
+
+PAPER_MD="$PAPER_DIR/paper.md"
+PREREG_MD="$PAPER_DIR/preregistration.md"
+
+cp "$REGISTRY_ROOT/docs/templates/paper.md" "$PAPER_MD"
+cp "$REGISTRY_ROOT/docs/templates/preregistration.md" "$PREREG_MD"
+
+sed -i \
+    -e "s|^title:.*|title: \"${TITLE_ESC}\"|" \
+    -e "s|^slug:.*|slug: ${SLUG_FULL}|" \
+    -e "s|^date:.*|date: ${TODAY}|" \
+    -e "s|^domain:.*|domain: ${DOMAIN_ESC}|" \
+    -e "s|^tags:.*|tags: ${TAGS_YAML}|" \
+    "$PAPER_MD"
+
+sed -i \
+    -e "s|^paper_slug:.*|paper_slug: ${SLUG_FULL}|" \
+    "$PREREG_MD"
+
+echo "  $PAPER_MD"
+echo "  $PREREG_MD"
+
+# ── references.md ────────────────────────────────────────────
+
+echo "[3/3] Escribiendo references.md..."
+cat > "$PAPER_DIR/references.md" << EOF
+# References — ${TITLE}
+
+<!-- Una entrada por referencia. Formato libre (o BibTeX) hasta promocionar a publishable. -->
+EOF
+echo "  $PAPER_DIR/references.md"
+
+# ── Resumen ──────────────────────────────────────────────────
+
+echo ""
+echo "════════════════════════════════════════════════════════════"
+echo "  PAPER '${SLUG_FULL}' LISTO (fase: question, status: draft)"
+echo "════════════════════════════════════════════════════════════"
+echo ""
+echo "  Pasos siguientes:"
+echo "  1. Revisión de literatura (skill /deep-research) → Related work."
+echo "  2. Pre-registro: congela H0/H1 + plan en preregistration.md (preregister_hypothesis)."
+echo "  3. Experimentos en experiments/ → análisis (grupo eda) → escritura IMRaD en paper.md."
+echo "  4. render_paper_pdf → out/paper.pdf. Peer review adversarial → reviews/."
+echo ""
+echo "  papers/ está gitignored: este paper vive local hasta promocionar a publishable."
+echo ""
@@ -39,6 +39,7 @@ Indice de grupos de capacidades del registry. Cada grupo agrupa >=3 funciones qu
 | [cpp-tables](tql.md) | 9 | Table Query Language C++ puro: filter, group, agg, sort, join, stats, formulas Lua, round-trip emit/apply |
 | [data-table-renderers](data_table_renderers.md) | 1 | API declarativa de cell renderers para data_table: Badge, Progress, Duration, Icon via TableInput.column_specs |
 | [scheduler](scheduler.md) | 4 | Cron expression parsing, matching, next-run y traduccion humana (consume `apps/dag_engine`) |
+| [papers](papers.md) | — | Papers académicos reproducibles en `papers/<NNNN-slug>/`: scaffold del artefacto (`init_paper` + helper `next_numbered_dir`), plantillas IMRaD + pre-registro anti-HARKing, y (en construcción por la flota) congelar hipótesis, funciones estadísticas (effect size/CI/corrección múltiple), render md→PDF y peer-review adversarial. Reutiliza `deep-research`, grupo `eda` y el motor PDF de `datascience`. Diseño: `reports/0001-2026-06-30-papers-system-design.md` |
 | [extractor](extractor.md) | 15 | Funciones que leen datos de fuentes externas (BD, API, archivos, web). Nodos input de `data_factory` |
 | [transformer](transformer.md) | 15 | Funciones que clean/dedup/aggregate/feature-engineer datos. Nodos intermedios de `data_factory` |
 | [sink](sink.md) | 11 | Funciones que escriben datos a destino externo (BD, dashboard, alerta, email). Nodos output |
@@ -0,0 +1,82 @@
+# papers — papers académicos reproducibles
+
+Grupo de capacidad para producir **papers académicos** dentro de `fn_registry`: investigación con hipótesis falsables, experimentos reproducibles, análisis estadístico honesto y escritura en formato IMRaD. Cada paper es un artefacto nuevo en `papers/<NNNN-slug>/` que reutiliza infraestructura existente (skill `deep-research` para la revisión de literatura, grupo `eda` para el análisis, motor md→PDF de `datascience`, patrón de verificación adversarial del orquestador) y añade lo que falta como funciones del registry.
+
+Diseño completo y decisiones: `reports/0001-2026-06-30-papers-system-design.md`.
+
+> **Regla de oro anti paper-mill:** una hipótesis que **podía** fallar + un experimento con riesgo real de refutación + estadística que no es teatro. Si no hay riesgo de refutación, no es un paper. Los claims nunca superan a la evidencia. El antídoto al HARKing es el **pre-registro**: el plan de análisis se congela *antes* de mirar los datos.
+
+## Estructura del artefacto
+
+```
+papers/0001-mi-paper/
+  paper.md            # frontmatter (title, slug, authors, date, status, phase, tags, domain, hypothesis_id) + cuerpo IMRaD
+  preregistration.md  # H0/H1 + plan de análisis CONGELADO (frozen_at + content_hash) antes de correr
+  references.md       # bibliografía
+  experiments/        # código / notebooks por experimento (exp01_*, exp02_*)
+  data/               # crudos + procesados (gitignored si pesa)
+  figures/            # gráficos generados
+  reviews/            # outputs del peer-review adversarial
+  out/                # paper.pdf — entregable final
+  .git/               # SOLO cuando promociona a fase publishable (sub-repo Gitea)
+```
+
+`papers/` está gitignored en el repo padre (solo `papers/.gitkeep` se versiona): un paper en fase interna no contamina el repo. Al promocionar a `status: publishable` se vuelve sub-repo Gitea `dataforge/<slug>` (como apps y analyses).
+
+### Fases (campo `phase` de `paper.md`)
+
+```
+question → review → hypothesis → design → running → analysis → writing → internal-review
+  → [DONE interno]  → polish → submitted          [solo en fase publishable]
+```
+
+## Funciones
+
+| ID | Pureza | Estado | Qué hace |
+|---|---|---|---|
+| `init_paper_bash_pipelines` | impure | ✅ disponible | Scaffold de `papers/<NNNN-slug>/`: calcula el siguiente NNNN, crea las subcarpetas, copia `paper.md` + `preregistration.md` con el frontmatter relleno (slug, title, date de hoy, `phase: question`, `status: draft`) y `references.md` vacío. NO hace `git init` (el paper arranca en fase interna local). |
+| `next_numbered_dir_bash_io` | impure | ✅ disponible | Dado un directorio, devuelve el siguiente número incremental de 4 dígitos (`0001`, `0002`, …) escaneando los subdirs con prefijo `NNNN-`. Helper de numeración de `init_paper` (reutilizable por reports/issues). |
+| `preregister_hypothesis` | impure | 🚧 en construcción (flota) | Congela el `preregistration.md` (H0/H1 + plan de análisis) con `frozen_at` + `content_hash`, pasa `status` a `frozen` y escribe `hypothesis_id` en `paper.md`. Mata el HARKing: tras congelar, el plan no se edita. |
+| `cohens_d` (effect size) | pure | 🚧 en construcción (flota) | Tamaño del efecto (Cohen's d) entre dos grupos. Reporta magnitud, no solo significancia. |
+| `confidence_interval` | pure | 🚧 en construcción (flota) | Intervalo de confianza de una métrica (media/diferencia). |
+| `holm_bonferroni` | pure | 🚧 en construcción (flota) | Corrección de comparaciones múltiples (Holm-Bonferroni / FWER) para el plan de análisis. |
+| `render_paper_pdf` | impure | 🚧 en construcción (flota) | Markdown IMRaD (`paper.md` + figuras) → `out/paper.pdf`, reutilizando el motor md→PDF del grupo `eda`/`datascience`. |
+
+> Las funciones estadísticas reutilizan lo que ya exista en `datascience` (p.ej. `fdr_correction_py_datascience` cubre la corrección de comparaciones múltiples por FDR; el agente del rigor experimental decide si añade Holm-Bonferroni o reusa lo existente). Buscar antes de duplicar: `mcp__registry__fn_search query="effect size" domain="datascience"`.
+
+### Peer review (no es función del registry)
+
+El agente adversarial `.claude/agents/paper-reviewer.md` (🚧 en construcción por la flota) puntúa novedad, rigor, reproducibilidad y validez, e intenta **refutar** cada claim. Default a "failed" si la evidencia no soporta. Escribe su veredicto en `reviews/`. Es el equivalente al verificador adversarial del orquestador aplicado al paper.
+
+## Ejemplo canónico (end-to-end)
+
+```bash
+# 1. Scaffold del paper (fase question, local). Crea papers/0001-mi-paper/.
+./fn run init_paper mi-paper --title "¿El bucle reactivo reduce las calls inline?" --domain datascience --tags registry,telemetria
+
+# 2. Revisión de literatura → llena Related work (skill deep-research, fase review).
+#    /deep-research "..."
+
+# 3. Pre-registro: congela H0/H1 + plan de análisis ANTES de mirar datos (fase hypothesis).
+./fn run preregister_hypothesis papers/0001-mi-paper      # 🚧 en construcción
+
+# 4. Experimentos en papers/0001-mi-paper/experiments/ (fase running) →
+#    análisis con el grupo `eda` + funciones de effect size / CI / corrección múltiple (fase analysis).
+
+# 5. Escritura IMRaD en paper.md (fase writing) → render del entregable PDF.
+./fn run render_paper_pdf papers/0001-mi-paper            # 🚧 en construcción → out/paper.pdf
+
+# 6. Peer review adversarial (fase internal-review).
+#    Agent(subagent_type="paper-reviewer", prompt="Revisa papers/0001-mi-paper ...")  # 🚧 en construcción
+```
+
+## Fronteras
+
+- **NO es para reports de trabajo.** Un report (`reports/`) es el entregable escrito de una tarea (resumen + evidencia + gaps); un paper es investigación con hipótesis falsable y experimento. Ver `.claude/rules/reports.md`.
+- **NO se indexa en `registry.db` en esta fase.** No hay tabla `papers` ni `entity_type` `paper` (KISS); se añadiría con migración propia si se decide. Las *funciones* del grupo sí se indexan (viven en `bash/functions/`, `python/functions/`), pero los artefactos `papers/<slug>/` no.
+- **NO hace `git init` en el scaffold.** El paper arranca en fase interna local y gitignored. La promoción a sub-repo Gitea (fase publishable) es un paso manual posterior.
+- **NO soporta LaTeX/arXiv todavía.** Formato elegido: Markdown como fuente + PDF como entregable. El soporte LaTeX se añadiría al promocionar un paper a fase publishable.
+
+## Estado
+
+Fase de scaffolding. Disponible: estructura del artefacto, plantillas (`docs/templates/paper.md`, `docs/templates/preregistration.md`), pipeline `init_paper` + helper `next_numbered_dir`, esta página y el bloque gitignore de `papers/`. En construcción por la flota: `preregister_hypothesis`, funciones estadísticas (effect size / CI / corrección múltiple), `render_paper_pdf` y el agente `paper-reviewer`. Validación end-to-end con un paper piloto real: pendiente.
@@ -0,0 +1,94 @@
+---
+title: "TITULO DEL PAPER"
+slug: NNNN-slug
+authors: [Enmanuel]
+date: 2026-01-01
+status: draft          # draft | internal | publishable
+phase: question        # question -> review -> hypothesis -> design -> running -> analysis -> writing -> internal-review -> polish -> submitted
+tags: []
+domain: datascience
+hypothesis_id: ""      # lo rellena preregister_hypothesis al congelar el preregistro
+---
+
+<!--
+Paper académico reproducible (formato IMRaD). Esta es la FUENTE editable en Markdown;
+el entregable PDF se genera con render_paper_pdf (grupo `papers`).
+
+Regla de oro anti paper-mill: una hipótesis que PODÍA fallar + un experimento con
+riesgo real de refutación + estadística que no es teatro. Si no hay riesgo de
+refutación, no es un paper. Los claims nunca superan a la evidencia.
+-->
+
+# {{título del paper}}
+
+## Abstract
+
+<!--
+Resumen estructurado en 4-6 frases: contexto -> gap -> método -> resultados -> conclusión.
+Sin citas, sin abreviaturas sin definir. Es lo único que mucha gente leerá: que se sostenga solo.
+-->
+
+## 1. Introduction
+
+<!--
+Embudo en cuatro movimientos:
+1. Contexto — el área y por qué importa.
+2. Gap — qué NO se sabe todavía (el hueco que este paper llena).
+3. Pregunta / hipótesis — formulada de forma falsable (ver preregistration.md).
+4. Contribución — lista explícita de lo que aporta este trabajo ("Contributions:").
+-->
+
+## 2. Related work
+
+<!--
+Qué existe ya y por qué no basta. Agrupa por enfoque, no por autor. Cada cita debe
+justificar por qué el gap sigue abierto. Output de la fase de revisión (skill deep-research).
+-->
+
+## 3. Methods
+
+<!--
+Diseño REPRODUCIBLE: otra persona lo corre y obtiene lo mismo.
+- Variables: independiente(s), dependiente(s), control.
+- Diseño: N, condiciones, muestreo, aleatorización.
+- Métricas y cómo se miden.
+- Protocolo paso a paso + dónde vive el código (experiments/) y los datos (data/).
+Debe ser coherente con el preregistration.md congelado (no se cambia el plan tras ver datos).
+-->
+
+## 4. Results
+
+<!--
+Datos SIN interpretar. Tablas y figuras (figures/) con su lectura literal.
+Reporta effect size + intervalos de confianza, no solo p-valores.
+Incluye también los resultados negativos / no significativos (anti cherry-picking).
+-->
+
+## 5. Discussion
+
+<!--
+Interpretación de los resultados a la luz de la pregunta. Claims <= evidencia.
+-->
+
+### 5.1 Limitaciones
+
+<!-- Qué no cubre el estudio, supuestos, datos faltantes. Honestidad explícita. -->
+
+### 5.2 Amenazas a la validez
+
+<!--
+- Validez interna — ¿la causa es lo que decimos o hay confusores?
+- Validez externa — ¿generaliza fuera de esta muestra/condiciones?
+- Validez de constructo — ¿la métrica mide lo que dice medir?
+- Validez estadística — ¿N suficiente, supuestos del test cumplidos, comparaciones múltiples corregidas?
+-->
+
+## 6. Conclusion + Future work
+
+<!--
+Cierre en 2-4 frases: qué se aprendió (sin overclaiming) + las siguientes preguntas que abre.
+-->
+
+## References
+
+<!-- Ver references.md. -->
@@ -0,0 +1,59 @@
+---
+paper_slug: NNNN-slug
+frozen_at: ""          # timestamp ISO — lo rellena preregister_hypothesis al congelar
+content_hash: ""       # hash del contenido congelado — lo rellena preregister_hypothesis
+status: draft          # draft -> frozen (preregister_hypothesis lo pasa a frozen; tras congelar NO se edita)
+---
+
+> **⚠️ ESTE DOCUMENTO SE CONGELA ANTES DE MIRAR LOS DATOS (anti-HARKing).**
+> El plan de análisis se fija aquí *antes* de ejecutar el experimento. Una vez congelado
+> (`status: frozen`, con `frozen_at` + `content_hash`), **no se edita**. Inventar o ajustar
+> la hipótesis después de ver los resultados (HARKing) invalida el paper. Si el plan cambia
+> tras ver datos, eso es análisis exploratorio y se reporta como tal, no como confirmatorio.
+
+# Pre-registro — {{título del paper}}
+
+## 1. Pregunta de investigación
+
+<!-- La pregunta concreta, en una frase. Debe poder responderse con un experimento. -->
+
+## 2. Hipótesis
+
+<!-- Falsable (Popper): una predicción que PODRÍA fallar. -->
+
+- **H0 (nula):** <!-- no hay efecto / no hay diferencia. Es lo que el test intenta rechazar. -->
+- **H1 (alternativa):** <!-- el efecto esperado, con dirección si la hay. -->
+
+## 3. Variables
+
+- **Independiente(s):** <!-- lo que se manipula. -->
+- **Dependiente(s):** <!-- lo que se mide (la métrica de resultado). -->
+- **Control:** <!-- lo que se mantiene fijo / se cubre estadísticamente. -->
+
+## 4. Diseño
+
+<!--
+- N: tamaño de muestra (y justificación / power analysis si aplica).
+- Condiciones / grupos.
+- Muestreo y aleatorización.
+- Criterios de inclusión / exclusión de datos (definidos AHORA, no después).
+-->
+
+## 5. Plan de análisis
+
+<!--
+El plan estadístico EXACTO, decidido antes de ver los datos:
+- Test estadístico concreto (p.ej. t-test de Welch, Mann-Whitney U, regresión...).
+- Métrica de effect size (p.ej. Cohen's d, diferencia de medias, odds ratio).
+- Criterio de decisión (umbral alpha, qué resultado confirma/refuta H1).
+- Corrección por comparaciones múltiples (p.ej. Holm-Bonferroni) si hay >1 contraste.
+- Manejo de supuestos (normalidad, varianzas) y qué se hace si no se cumplen.
+-->
+
+## 6. Predicción cuantitativa
+
+<!--
+La predicción numérica concreta que el experimento pondrá a prueba.
+P.ej. "esperamos d >= 0.5 con IC95% que no cruza 0" o "una reducción >= 15% en la métrica X".
+Cuanto más específica, más falsable.
+-->
@@ -59,9 +59,6 @@ from .acf_pacf import acf_pacf
 from .stl_decompose import stl_decompose
 from .to_returns import to_returns
 from .fdr_correction import fdr_correction
-from .effect_size_cohens_d import effect_size_cohens_d
-from .confidence_interval_mean import confidence_interval_mean
-from .preregister_hypothesis import preregister_hypothesis
 from .suggest_reexpression import suggest_reexpression
 from .exploratory_caveats import exploratory_caveats
 from .render_eda_pdf import render_eda_pdf, render_eda_pdf_relational
@@ -93,9 +90,6 @@ __all__ = [
    "stl_decompose",
    "to_returns",
    "fdr_correction",
-    "effect_size_cohens_d",
-    "confidence_interval_mean",
-    "preregister_hypothesis",
    "suggest_reexpression",
    "exploratory_caveats",
    "render_eda_pdf",
@@ -1,87 +0,0 @@
---
-name: confidence_interval_mean
-kind: function
-lang: py
-domain: datascience
-version: "1.0.0"
-purity: pure
-signature: "def confidence_interval_mean(data: list, other: list = None, confidence: float = 0.95) -> dict"
-description: "Intervalo de confianza (IC) de la media de una muestra con la t de Student, o de la DIFERENCIA de medias de dos muestras independientes con el metodo de Welch (sin asumir varianzas iguales). Una muestra: df=n-1, se=sd_muestral/sqrt(n) (sd con ddof=1), tcrit=t.ppf((1+confidence)/2, df), ci=mean+/-tcrit*se. Dos muestras: IC de mean(data)-mean(other) con se=sqrt(se1^2+se2^2) y grados de libertad de Welch-Satterthwaite. Pura y robusta: nunca lanza; ante casos degenerados (muestra vacia, n<2) devuelve nan + clave note, y con varianza cero el IC colapsa al punto (no es error). Usa scipy.stats y numpy."
-tags: [papers, statistics, confidence-interval, welch, t-test, python]
-params:
-  - name: data
-    desc: "muestra de observaciones numericas (lista de numeros). Si other es None, el IC es el de la media de data."
-  - name: other
-    desc: "segunda muestra independiente (lista de numeros) o None (default). Si se da, el IC es el de la diferencia de medias mean(data)-mean(other) calculada con Welch (no asume varianzas iguales)."
-  - name: confidence
-    desc: "nivel de confianza en (0, 1); 0.95 = IC del 95% (default). El cuantil critico es t.ppf((1+confidence)/2, df)."
-output: "dict {mean, ci_low, ci_high, se, df, confidence, n}. mean = media de data (una muestra) o la diferencia mean(data)-mean(other) (dos muestras). En el caso de dos muestras se anaden ademas n1 y n2 (y n = n1+n2). df son los grados de libertad de la t (Welch-Satterthwaite si dos muestras). Casos degenerados (muestra vacia, n<2) anaden la clave note y dejan ci_low/ci_high/se (y a veces df) en nan; con varianza cero y n>=2 el IC colapsa a [mean, mean] con se=0 (con note, sin nan). Nunca None ni excepcion."
-uses_functions: []
-uses_types: []
-returns: []
-returns_optional: false
-error_type: ""
-imports: [scipy, numpy]
-tested: true
-tests: ["test_one_sample_golden_contra_scipy", "test_one_sample_distinto_nivel_confianza", "test_welch_diferencia_golden_contra_scipy", "test_edge_un_solo_elemento_no_lanza_nan_note", "test_edge_lista_vacia_no_lanza_note", "test_edge_varianza_cero_colapsa_al_punto", "test_edge_welch_muestra_vacia_no_lanza_note", "test_edge_welch_n1_uno_no_lanza_note"]
-test_file_path: "python/functions/datascience/confidence_interval_mean_test.py"
-file_path: "python/functions/datascience/confidence_interval_mean.py"
---
-
-## Ejemplo
-
-```python
-from datascience import confidence_interval_mean
-
-# IC del 95% de la media de una muestra (t de Student).
-data = [2, 4, 4, 4, 5, 5, 7, 9]
-ci = confidence_interval_mean(data, confidence=0.95)
-print(ci["mean"])     # -> 5.0
-print(ci["df"])       # -> 7.0  (n - 1)
-print(round(ci["ci_low"], 5), round(ci["ci_high"], 5))
-# -> 3.21251 6.78749   (se con sd muestral ddof=1 ~ 2.13809)
-
-# IC del 95% de la DIFERENCIA de medias (Welch, no asume varianzas iguales).
-control = [23.0, 21.0, 25.0, 22.0, 24.0, 26.0]
-tratado = [18.0, 20.0, 17.0, 19.0, 21.0]
-diff = confidence_interval_mean(control, tratado, confidence=0.95)
-print(diff["mean"])   # -> 4.5  (mean(control) - mean(tratado))
-print(round(diff["ci_low"], 4), round(diff["ci_high"], 4))
-# Si el intervalo no incluye 0, la diferencia es significativa al 5%.
-
-# Degenerados: nunca lanza.
-print(confidence_interval_mean([5])["note"])      # n < 2: ... indefinidos
-print(confidence_interval_mean([3, 3, 3])["se"])  # -> 0.0  (IC colapsa a [3, 3])
-```
-
-## Cuando usarla
-
-Cuando quieras cuantificar la **incertidumbre de una media estimada** a partir de
-una muestra: reporta `[ci_low, ci_high]` en vez de un punto suelto para mostrar
-el rango plausible del valor real al nivel de confianza pedido. Usala tambien
-para **comparar dos grupos** (A/B test, control vs tratamiento, antes vs
-despues con grupos independientes): pasa las dos muestras y, si el IC de la
-diferencia **no incluye el 0**, la diferencia es significativa al nivel
-`1 - confidence`. Es el complemento del p-valor: ademas de "hay efecto", te dice
-"de que tamano y con que margen". Para dos muestras usa Welch por defecto, asi
-que no necesitas comprobar antes si las varianzas son iguales.
-
-## Gotchas
-
- Pura y determinista (no hace I/O, no muta las entradas), pero **no** es
-  stdlib-only: depende de `scipy.stats` y `numpy` (ambos en el venv del proyecto).
- Con `other` usa **Welch** (df de Welch-Satterthwaite): NO asume varianzas
-  iguales ni tamanos de muestra iguales. Si necesitas el t-test clasico de
-  varianzas agrupadas (pooled), esta funcion no lo hace.
- `sd` se calcula con **ddof=1** (sd muestral), que es lo correcto para el IC de
-  una media con la t. Atajos como `sd_poblacional/sqrt(n)` (ddof=0) dan un
-  intervalo demasiado estrecho.
- En el caso de dos muestras, `mean` es la **diferencia** `mean(data) - mean(other)`
-  (no la media de data). El orden importa: el signo del IC depende de cual va
-  primero.
- Nunca lanza. Casos degenerados devuelven `nan` en `ci_low`/`ci_high`/`se`
-  (y a veces `df`) mas una clave `note`: muestra vacia o `n < 2` en cualquiera de
-  las muestras. **Excepcion**: con varianza cero y `n >= 2` el IC colapsa al
-  punto `[mean, mean]` con `se = 0` (no es un error, no hay `nan`).
- Comprueba `"note" in out` antes de usar `ci_low`/`ci_high` si la muestra puede
-  ser degenerada.
@@ -1,176 +0,0 @@
-"""Intervalo de confianza de la media (una muestra) o de la diferencia de medias (Welch).
-
-Funcion pura del grupo papers. Calcula el intervalo de confianza (IC) de la media
-de una muestra usando la t de Student, o el IC de la diferencia de medias de dos
-muestras independientes con el metodo de Welch (sin asumir varianzas iguales).
-
- Una muestra: ``df = n - 1``, ``se = sd / sqrt(n)`` (sd con ddof=1),
-  ``tcrit = t.ppf((1 + confidence) / 2, df)``, ``ci = mean +/- tcrit * se``.
- Dos muestras (Welch): IC de ``mean(data) - mean(other)``, con
-  ``se = sqrt(se1^2 + se2^2)`` y grados de libertad de Welch-Satterthwaite.
-
-No lanza excepciones: ante casos degenerados (muestras vacias, ``n < 2``,
-varianza cero) devuelve un dict coherente con ``ci_low``/``ci_high``/``se`` en
-``nan`` (salvo el sub-caso de varianza cero, donde el IC colapsa al punto) y una
-clave ``note`` explicando el caso. Usa ``scipy.stats`` y ``numpy``.
-"""
-
-from __future__ import annotations
-
-import math
-
-import numpy as np
-from scipy import stats
-
-
-def confidence_interval_mean(
-    data: list, other: list = None, confidence: float = 0.95
-) -> dict:
-    """Intervalo de confianza de la media o de la diferencia de medias (Welch).
-
-    Si ``other`` es ``None``, calcula el IC de la media de ``data`` con la t de
-    Student. Si se proporciona ``other``, calcula el IC de la diferencia
-    ``mean(data) - mean(other)`` con el metodo de Welch (no asume varianzas
-    iguales) y grados de libertad de Welch-Satterthwaite.
-
-    Es una funcion pura y determinista: no hace I/O ni muta las entradas. No
-    lanza excepcion ante datos degenerados; en su lugar devuelve un dict con la
-    clave ``note`` y los campos numericos indefinidos a ``nan``.
-
-    Args:
-        data: muestra de observaciones numericas (lista de numeros).
-        other: segunda muestra independiente. Si se da, el IC es el de la
-            diferencia de medias ``mean(data) - mean(other)`` con Welch. Si es
-            ``None`` (default), el IC es el de la media de ``data``.
-        confidence: nivel de confianza en (0, 1), p.ej. 0.95 para el 95%.
-
-    Returns:
-        dict con las claves:
-            mean: media de ``data`` (una muestra) o la diferencia
-                ``mean(data) - mean(other)`` (dos muestras).
-            ci_low: extremo inferior del intervalo de confianza.
-            ci_high: extremo superior del intervalo de confianza.
-            se: error estandar de la media (o de la diferencia).
-            df: grados de libertad de la t (Welch-Satterthwaite si dos muestras).
-            confidence: nivel de confianza aplicado (float).
-            n: tamano de la muestra (una muestra) o tamano total ``n1 + n2``
-                (dos muestras; ademas se incluyen ``n1`` y ``n2``).
-
-        En el caso de dos muestras se incluyen ademas ``n1`` y ``n2``. Casos
-        degenerados (muestra vacia, ``n < 2``, etc.) anaden la clave ``note`` y
-        dejan ``ci_low``/``ci_high``/``se`` (y a veces ``df``) en ``nan``.
-    """
-    conf = float(confidence)
-
-    if other is None:
-        return _ci_one_sample(data, conf)
-    return _ci_welch(data, other, conf)
-
-
-def _ci_one_sample(data: list, conf: float) -> dict:
-    """IC de la media de una sola muestra con la t de Student."""
-    arr = np.asarray(list(data), dtype=float)
-    n = int(arr.size)
-
-    base = {
-        "mean": float("nan"),
-        "ci_low": float("nan"),
-        "ci_high": float("nan"),
-        "se": float("nan"),
-        "df": float("nan"),
-        "confidence": conf,
-        "n": n,
-    }
-
-    if n == 0:
-        base["note"] = "muestra vacia: media e intervalo indefinidos"
-        return base
-
-    mean = float(arr.mean())
-    base["mean"] = mean
-
-    if n < 2:
-        base["note"] = "n < 2: error estandar y grados de libertad indefinidos"
-        return base
-
-    df = n - 1
-    base["df"] = float(df)
-
-    sd = float(arr.std(ddof=1))
-    se = sd / math.sqrt(n)
-    base["se"] = se
-
-    # Varianza cero: el IC colapsa al punto (no es un error).
-    if se == 0.0:
-        base["ci_low"] = mean
-        base["ci_high"] = mean
-        base["note"] = "varianza cero: el intervalo colapsa a la media"
-        return base
-
-    tcrit = float(stats.t.ppf((1.0 + conf) / 2.0, df))
-    margin = tcrit * se
-    base["ci_low"] = mean - margin
-    base["ci_high"] = mean + margin
-    return base
-
-
-def _ci_welch(data: list, other: list, conf: float) -> dict:
-    """IC de la diferencia de medias de dos muestras con el metodo de Welch."""
-    a = np.asarray(list(data), dtype=float)
-    b = np.asarray(list(other), dtype=float)
-    n1 = int(a.size)
-    n2 = int(b.size)
-
-    base = {
-        "mean": float("nan"),
-        "ci_low": float("nan"),
-        "ci_high": float("nan"),
-        "se": float("nan"),
-        "df": float("nan"),
-        "confidence": conf,
-        "n": n1 + n2,
-        "n1": n1,
-        "n2": n2,
-    }
-
-    if n1 == 0 or n2 == 0:
-        base["note"] = "alguna muestra esta vacia: diferencia e intervalo indefinidos"
-        return base
-
-    mean1 = float(a.mean())
-    mean2 = float(b.mean())
-    diff = mean1 - mean2
-    base["mean"] = diff
-
-    if n1 < 2 or n2 < 2:
-        base["note"] = (
-            "n < 2 en alguna muestra: error estandar y grados de libertad indefinidos"
-        )
-        return base
-
-    sd1 = float(a.std(ddof=1))
-    sd2 = float(b.std(ddof=1))
-    se1 = sd1 / math.sqrt(n1)
-    se2 = sd2 / math.sqrt(n2)
-    se = math.sqrt(se1 * se1 + se2 * se2)
-    base["se"] = se
-
-    # Ambas varianzas cero: el IC de la diferencia colapsa al punto.
-    if se == 0.0:
-        base["ci_low"] = diff
-        base["ci_high"] = diff
-        base["df"] = float("nan")
-        base["note"] = "varianza cero en ambas muestras: el intervalo colapsa a la diferencia"
-        return base
-
-    # Grados de libertad de Welch-Satterthwaite.
-    df = (se1 * se1 + se2 * se2) ** 2 / (
-        (se1**4) / (n1 - 1) + (se2**4) / (n2 - 1)
-    )
-    base["df"] = float(df)
-
-    tcrit = float(stats.t.ppf((1.0 + conf) / 2.0, df))
-    margin = tcrit * se
-    base["ci_low"] = diff - margin
-    base["ci_high"] = diff + margin
-    return base
@@ -1,140 +0,0 @@
-"""Tests para confidence_interval_mean (IC de la media / diferencia de medias Welch).
-
-Importa el modulo hoja directamente (`confidence_interval_mean`) para no depender
-de que el paquete reexporte la funcion en su __init__ (lo integra el orquestador
-al cerrar el grupo).
-
-Los golden se calculan con scipy dentro del propio test para que sean robustos:
-la funcion bajo prueba debe coincidir con la referencia de scipy a ~1e-9.
-"""
-
-import math
-
-import numpy as np
-from scipy import stats
-
-from confidence_interval_mean import confidence_interval_mean
-
-
-def test_one_sample_golden_contra_scipy():
-    # mean=5.0, n=8. Este dataset tiene sd POBLACIONAL (ddof=0) exactamente 2.0,
-    # pero la sd MUESTRAL (ddof=1, la que exige la spec y la que es correcta para
-    # el IC de una media con la t) es sqrt(32/7) ~ 2.13809. El golden robusto se
-    # calcula con scipy usando se con ddof=1, no con el atajo 2.0/sqrt(8).
-    data = [2, 4, 4, 4, 5, 5, 7, 9]
-    out = confidence_interval_mean(data, confidence=0.95)
-
-    n = len(data)
-    mean = float(np.mean(data))
-    sd = float(np.std(data, ddof=1))  # sample sd ~ 2.13809
-    se = sd / math.sqrt(n)
-    lo, hi = stats.t.interval(0.95, df=n - 1, loc=mean, scale=se)
-
-    assert abs(out["mean"] - 5.0) < 1e-9
-    assert abs(out["se"] - se) < 1e-12
-    assert out["df"] == 7.0
-    assert out["n"] == 8
-    assert out["confidence"] == 0.95
-    assert abs(out["ci_low"] - lo) < 1e-9
-    assert abs(out["ci_high"] - hi) < 1e-9
-    # Valores tabulados correctos para ddof=1 (no los 3.32793/6.67207 del
-    # enunciado, que asumian erroneamente sd=2.0 / ddof=0).
-    assert abs(out["ci_low"] - 3.21251) < 1e-3
-    assert abs(out["ci_high"] - 6.78749) < 1e-3
-    assert "note" not in out
-
-
-def test_one_sample_distinto_nivel_confianza():
-    data = [10.0, 12.0, 11.0, 13.0, 9.0, 14.0]
-    out = confidence_interval_mean(data, confidence=0.99)
-
-    n = len(data)
-    mean = float(np.mean(data))
-    se = float(np.std(data, ddof=1)) / math.sqrt(n)
-    lo, hi = stats.t.interval(0.99, df=n - 1, loc=mean, scale=se)
-
-    assert abs(out["mean"] - mean) < 1e-12
-    assert abs(out["ci_low"] - lo) < 1e-9
-    assert abs(out["ci_high"] - hi) < 1e-9
-    assert out["df"] == float(n - 1)
-
-
-def test_welch_diferencia_golden_contra_scipy():
-    data = [23.0, 21.0, 25.0, 22.0, 24.0, 26.0]
-    other = [18.0, 20.0, 17.0, 19.0, 21.0]
-    conf = 0.95
-    out = confidence_interval_mean(data, other, confidence=conf)
-
-    a = np.asarray(data, dtype=float)
-    b = np.asarray(other, dtype=float)
-    n1, n2 = a.size, b.size
-    mean1, mean2 = float(a.mean()), float(b.mean())
-    diff = mean1 - mean2
-    se1 = float(a.std(ddof=1)) / math.sqrt(n1)
-    se2 = float(b.std(ddof=1)) / math.sqrt(n2)
-    se = math.sqrt(se1**2 + se2**2)
-    df = (se1**2 + se2**2) ** 2 / (se1**4 / (n1 - 1) + se2**4 / (n2 - 1))
-    lo, hi = stats.t.interval(conf, df=df, loc=diff, scale=se)
-
-    assert abs(out["mean"] - diff) < 1e-9
-    assert abs(out["mean"] - (mean1 - mean2)) < 1e-9
-    assert abs(out["se"] - se) < 1e-12
-    assert abs(out["df"] - df) < 1e-9
-    assert abs(out["ci_low"] - lo) < 1e-9
-    assert abs(out["ci_high"] - hi) < 1e-9
-    assert out["n1"] == n1
-    assert out["n2"] == n2
-    assert out["n"] == n1 + n2
-    assert "note" not in out
-
-
-def test_edge_un_solo_elemento_no_lanza_nan_note():
-    out = confidence_interval_mean([5], confidence=0.95)
-    assert out["mean"] == 5.0  # la media si esta definida con n=1
-    assert math.isnan(out["se"])
-    assert math.isnan(out["ci_low"])
-    assert math.isnan(out["ci_high"])
-    assert math.isnan(out["df"])
-    assert out["n"] == 1
-    assert "note" in out
-
-
-def test_edge_lista_vacia_no_lanza_note():
-    out = confidence_interval_mean([], confidence=0.95)
-    assert math.isnan(out["mean"])
-    assert math.isnan(out["ci_low"])
-    assert math.isnan(out["ci_high"])
-    assert math.isnan(out["se"])
-    assert out["n"] == 0
-    assert "note" in out
-
-
-def test_edge_varianza_cero_colapsa_al_punto():
-    out = confidence_interval_mean([3, 3, 3], confidence=0.95)
-    assert out["mean"] == 3.0
-    assert out["se"] == 0.0
-    assert out["ci_low"] == 3.0
-    assert out["ci_high"] == 3.0
-    assert not math.isnan(out["ci_low"])
-    assert out["n"] == 3
-    assert "note" in out
-
-
-def test_edge_welch_muestra_vacia_no_lanza_note():
-    out = confidence_interval_mean([1.0, 2.0, 3.0], [], confidence=0.95)
-    assert math.isnan(out["mean"])
-    assert math.isnan(out["ci_low"])
-    assert math.isnan(out["se"])
-    assert out["n1"] == 3
-    assert out["n2"] == 0
-    assert "note" in out
-
-
-def test_edge_welch_n1_uno_no_lanza_note():
-    out = confidence_interval_mean([5.0], [1.0, 2.0, 3.0], confidence=0.95)
-    # La diferencia de medias si esta definida.
-    assert abs(out["mean"] - (5.0 - 2.0)) < 1e-9
-    assert math.isnan(out["se"])
-    assert math.isnan(out["ci_low"])
-    assert math.isnan(out["df"])
-    assert "note" in out
@@ -1,80 +0,0 @@
---
-name: effect_size_cohens_d
-kind: function
-lang: py
-domain: datascience
-version: "1.0.0"
-purity: pure
-signature: "def effect_size_cohens_d(group_a: list, group_b: list) -> dict"
-description: "Tamano del efecto (effect size) entre dos grupos numericos: Cohen's d (diferencia de medias estandarizada por la desviacion tipica combinada, varianzas muestrales ddof=1), Hedges' g (d corregido por el sesgo al alza con muestras pequenas via el factor J) e interpretacion cualitativa de la magnitud segun los umbrales clasicos de Cohen (negligible/small/medium/large). El p-valor dice si hay diferencia; el effect size dice como de grande, de forma adimensional e independiente del N. Pura, sin dependencias externas; nunca lanza: los casos degenerados (varianza cero, N<2, listas vacias) devuelven NaN + una clave note."
-tags: [papers, statistics, effect-size, cohens-d, hedges-g, python]
-params:
-  - name: group_a
-    desc: "primera muestra (lista de numeros). Necesita >=2 observaciones para que exista la varianza muestral (ddof=1)."
-  - name: group_b
-    desc: "segunda muestra (lista de numeros). Necesita >=2 observaciones. El signo de cohens_d es positivo cuando mean_a > mean_b."
-output: "dict {cohens_d: float (diferencia de medias estandarizada, puede ser NaN), hedges_g: float (cohens_d * factor de correccion J, puede ser NaN), interpretation: str ('negligible'|'small'|'medium'|'large', o 'undefined' en casos degenerados), n_a: int, n_b: int, mean_a: float, mean_b: float, pooled_sd: float (desviacion tipica combinada)}. Casos degenerados (varianza cero en ambos grupos, N<2 en algun grupo, o listas vacias) anaden clave note. Nunca None ni excepcion."
-uses_functions: []
-uses_types: []
-returns: []
-returns_optional: false
-error_type: ""
-imports: [math]
-tested: true
-tests: ["test_golden_large_effect", "test_hedges_g_menor_en_magnitud_que_cohens_d", "test_interpretation_thresholds", "test_signo_positivo_cuando_a_mayor_que_b", "test_varianza_cero_no_lanza", "test_n_insuficiente_no_lanza", "test_listas_vacias_no_lanza", "test_un_grupo_vacio_no_lanza"]
-test_file_path: "python/functions/datascience/effect_size_cohens_d_test.py"
-file_path: "python/functions/datascience/effect_size_cohens_d.py"
---
-
-## Ejemplo
-
-```python
-from datascience import effect_size_cohens_d
-
-# Dos grupos desplazados 2 unidades, misma dispersion.
-a = [1, 2, 3, 4, 5]   # media 3, varianza muestral 2.5
-b = [3, 4, 5, 6, 7]   # media 5, varianza muestral 2.5
-
-out = effect_size_cohens_d(a, b)
-print(out["cohens_d"])        # -> -1.264911...  (a esta 1.26 SD por debajo de b)
-print(out["hedges_g"])        # -> -1.142500...  (|g| < |d|: correccion N pequeno)
-print(out["interpretation"])  # -> "large"       (|d| >= 0.8)
-print(out["pooled_sd"])       # -> 1.581138...
-
-# Caso degenerado: varianza cero -> no lanza, NaN + note.
-deg = effect_size_cohens_d([5, 5, 5], [5, 5, 5])
-print(deg["interpretation"])  # -> "undefined"
-print(deg["note"])            # -> "varianza cero, effect size indefinido"
-```
-
-## Cuando usarla
-
-Cuando ya sepas que dos grupos difieren (o quieras cuantificar su diferencia)
-y necesites una medida **de magnitud, no de significancia**: comparar el antes
-y el despues de una intervencion, el grupo control frente al tratamiento, o dos
-cohortes. Reportala junto al p-valor para responder "¿como de grande es la
-diferencia?" — un p-valor minusculo con N enorme puede esconder un efecto
-trivial. Es adimensional (en unidades de desviaciones tipicas), asi que hace
-comparables resultados entre estudios y alimenta meta-analisis. Usa **Hedges' g**
-en lugar de Cohen's d cuando los grupos sean pequenos (decenas o menos): d
-sobreestima el efecto y g lo corrige.
-
-## Gotchas
-
- Pura y sin dependencias externas (solo `math` de la stdlib).
- Usa **varianza muestral** (ddof=1), no poblacional. Por eso cada grupo
-  necesita al menos 2 observaciones; con N=1 la varianza muestral no existe y la
-  funcion devuelve NaN + `note`.
- **Nunca lanza excepcion**. Los casos degenerados devuelven `cohens_d` y
-  `hedges_g` a `float('nan')`, `interpretation="undefined"` y una clave `note`:
-  varianza cero en ambos grupos (`pooled_sd == 0`), N<2 en algun grupo, o listas
-  vacias. Comprueba con `math.isnan(out["cohens_d"])` o la presencia de `note`
-  antes de usar el resultado.
- El **signo** de `cohens_d` depende del orden de los argumentos: positivo si
-  `mean_a > mean_b`, negativo en caso contrario. La `interpretation` usa `|d|`,
-  asi que no depende del orden.
- `pooled_sd` asume varianzas comparables entre grupos (homogeneidad). Si las
-  dispersiones son muy distintas, Cohen's d clasico pierde precision; considera
-  variantes (Glass's delta) fuera del alcance de esta funcion.
- Los umbrales de Cohen (0.2 / 0.5 / 0.8) son convencion, no ley: interpretalos
-  segun el dominio.
@@ -1,156 +0,0 @@
-"""Effect size de dos grupos: Cohen's d, Hedges' g e interpretacion cualitativa.
-
-Funcion pura del grupo papers. El p-valor responde a "¿hay diferencia?" pero no
-a "¿como de grande es?". El tamano del efecto (effect size) cuantifica la
-magnitud de la diferencia entre dos grupos de forma adimensional, independiente
-del N, y es lo que hace comparables resultados entre estudios (meta-analisis).
-
- Cohen's d: diferencia de medias estandarizada por la desviacion tipica
-  combinada (pooled SD), con varianzas muestrales (ddof=1).
- Hedges' g: Cohen's d corregido por el sesgo al alza que sufre d con muestras
-  pequenas, multiplicando por el factor de correccion J.
- interpretation: etiqueta cualitativa de |d| segun los umbrales clasicos de
-  Cohen (negligible / small / medium / large).
-
-No usa dependencias externas: aritmetica de la libreria estandar (``math``).
-"""
-
-from __future__ import annotations
-
-import math
-
-
-def _mean(xs: list) -> float:
-    """Media aritmetica de una lista no vacia de numeros."""
-    return sum(float(x) for x in xs) / len(xs)
-
-
-def _sample_variance(xs: list, mean: float) -> float:
-    """Varianza muestral (ddof=1) de una lista con al menos 2 elementos."""
-    n = len(xs)
-    return sum((float(x) - mean) ** 2 for x in xs) / (n - 1)
-
-
-def _interpret(abs_d: float) -> str:
-    """Etiqueta cualitativa del tamano del efecto segun |d| (umbrales de Cohen)."""
-    if abs_d < 0.2:
-        return "negligible"
-    if abs_d < 0.5:
-        return "small"
-    if abs_d < 0.8:
-        return "medium"
-    return "large"
-
-
-def effect_size_cohens_d(group_a: list, group_b: list) -> dict:
-    """Calcula el tamano del efecto entre dos grupos numericos.
-
-    Devuelve Cohen's d (diferencia de medias estandarizada por la pooled SD),
-    Hedges' g (d corregido por sesgo de muestra pequena) y una etiqueta
-    cualitativa de la magnitud segun los umbrales de Cohen.
-
-    Es una funcion pura y determinista: no hace I/O, no muta la entrada. No lanza
-    excepcion ante datos degenerados; en su lugar devuelve un dict con
-    ``cohens_d`` / ``hedges_g`` a ``float('nan')``, ``interpretation`` a
-    ``"undefined"`` y una clave ``note`` explicando el caso.
-
-    Definiciones:
-        s_pooled = sqrt(((n1-1)*s1^2 + (n2-1)*s2^2) / (n1+n2-2)), con s1^2, s2^2
-            varianzas muestrales (ddof=1).
-        cohens_d = (mean_a - mean_b) / s_pooled.
-        J = 1 - 3 / (4*(n1+n2) - 9)  (factor de correccion de Hedges).
-        hedges_g = cohens_d * J.
-
-    Args:
-        group_a: primera muestra (lista de numeros). Necesita >=2 elementos para
-            que exista la varianza muestral.
-        group_b: segunda muestra (lista de numeros). Necesita >=2 elementos.
-
-    Returns:
-        dict con las claves:
-            cohens_d: float, diferencia de medias estandarizada (puede ser NaN).
-            hedges_g: float, Cohen's d corregido por sesgo (puede ser NaN).
-            interpretation: str, "negligible" | "small" | "medium" | "large", o
-                "undefined" en casos degenerados.
-            n_a: int, tamano de group_a.
-            n_b: int, tamano de group_b.
-            mean_a: float, media de group_a (NaN si vacio).
-            mean_b: float, media de group_b (NaN si vacio).
-            pooled_sd: float, desviacion tipica combinada (NaN si indefinida).
-
-        Casos degenerados (lista vacia, N<2 en algun grupo, o varianza cero en
-        ambos grupos -> pooled_sd == 0) anaden ademas una clave ``note``.
-    """
-    nan = float("nan")
-    n_a = len(group_a)
-    n_b = len(group_b)
-
-    # Listas vacias: ni media ni varianza definidas.
-    if n_a == 0 or n_b == 0:
-        return {
-            "cohens_d": nan,
-            "hedges_g": nan,
-            "interpretation": "undefined",
-            "n_a": n_a,
-            "n_b": n_b,
-            "mean_a": _mean(group_a) if n_a else nan,
-            "mean_b": _mean(group_b) if n_b else nan,
-            "pooled_sd": nan,
-            "note": "grupo vacio: media y varianza indefinidas, effect size indefinido",
-        }
-
-    mean_a = _mean(group_a)
-    mean_b = _mean(group_b)
-
-    # N insuficiente: la varianza muestral (ddof=1) no existe con un solo dato,
-    # y la correccion de Hedges no es fiable.
-    if n_a < 2 or n_b < 2:
-        return {
-            "cohens_d": nan,
-            "hedges_g": nan,
-            "interpretation": "undefined",
-            "n_a": n_a,
-            "n_b": n_b,
-            "mean_a": mean_a,
-            "mean_b": mean_b,
-            "pooled_sd": nan,
-            "note": (
-                "N insuficiente: cada grupo necesita >=2 observaciones para la "
-                "varianza muestral; effect size indefinido"
-            ),
-        }
-
-    var_a = _sample_variance(group_a, mean_a)
-    var_b = _sample_variance(group_b, mean_b)
-    pooled_sd = math.sqrt(
-        ((n_a - 1) * var_a + (n_b - 1) * var_b) / (n_a + n_b - 2)
-    )
-
-    # Varianza cero en ambos grupos: no se puede estandarizar (division por 0).
-    if pooled_sd == 0.0:
-        return {
-            "cohens_d": nan,
-            "hedges_g": nan,
-            "interpretation": "undefined",
-            "n_a": n_a,
-            "n_b": n_b,
-            "mean_a": mean_a,
-            "mean_b": mean_b,
-            "pooled_sd": 0.0,
-            "note": "varianza cero, effect size indefinido",
-        }
-
-    cohens_d = (mean_a - mean_b) / pooled_sd
-    j = 1.0 - 3.0 / (4.0 * (n_a + n_b) - 9.0)
-    hedges_g = cohens_d * j
-
-    return {
-        "cohens_d": cohens_d,
-        "hedges_g": hedges_g,
-        "interpretation": _interpret(abs(cohens_d)),
-        "n_a": n_a,
-        "n_b": n_b,
-        "mean_a": mean_a,
-        "mean_b": mean_b,
-        "pooled_sd": pooled_sd,
-    }
@@ -1,96 +0,0 @@
-"""Tests para effect_size_cohens_d (tamano del efecto de dos grupos).
-
-Importa el modulo hoja directamente (`effect_size_cohens_d`) para no depender de
-que el paquete reexporte la funcion en su __init__ (lo integra el orquestador al
-cerrar el grupo papers). El pytest del repo tiene pythonpath=["functions", ...],
-asi que el modulo hoja se resuelve por su nombre directo.
-"""
-
-import math
-
-from effect_size_cohens_d import effect_size_cohens_d
-
-
-def test_golden_large_effect():
-    # group_a: mean 3, var muestral 2.5; group_b: mean 5, var 2.5.
-    # pooled_sd = sqrt(2.5) ~= 1.5811388.
-    # cohens_d = (3-5)/1.5811388 ~= -1.264911.
-    # J = 1 - 3/(4*10-9) = 1 - 3/31 = 0.9032258.
-    # hedges_g = d * J = -1.2649111 * 0.9032258 ~= -1.142500.
-    out = effect_size_cohens_d([1, 2, 3, 4, 5], [3, 4, 5, 6, 7])
-    assert abs(out["cohens_d"] - (-1.26491)) < 1e-4
-    assert abs(out["hedges_g"] - (-1.14250)) < 1e-4
-    assert out["interpretation"] == "large"
-    assert out["n_a"] == 5
-    assert out["n_b"] == 5
-    assert abs(out["mean_a"] - 3.0) < 1e-12
-    assert abs(out["mean_b"] - 5.0) < 1e-12
-    assert abs(out["pooled_sd"] - math.sqrt(2.5)) < 1e-9
-    assert "note" not in out
-
-
-def test_hedges_g_menor_en_magnitud_que_cohens_d():
-    # La correccion J esta en (0, 1), asi que |g| < |d| siempre.
-    out = effect_size_cohens_d([1, 2, 3, 4, 5], [3, 4, 5, 6, 7])
-    assert abs(out["hedges_g"]) < abs(out["cohens_d"])
-
-
-def test_interpretation_thresholds():
-    # negligible: |d| < 0.2. Medias casi iguales con varianza grande.
-    neg = effect_size_cohens_d([0, 10, 20, 30], [1, 11, 21, 31])
-    assert neg["interpretation"] == "negligible"
-    assert abs(neg["cohens_d"]) < 0.2
-
-    # small: 0.2 <= |d| < 0.5.
-    small = effect_size_cohens_d([0, 10, 20, 30], [4, 14, 24, 34])
-    assert small["interpretation"] == "small"
-    assert 0.2 <= abs(small["cohens_d"]) < 0.5
-
-    # medium: 0.5 <= |d| < 0.8.
-    medium = effect_size_cohens_d([0, 10, 20, 30], [9, 19, 29, 39])
-    assert medium["interpretation"] == "medium"
-    assert 0.5 <= abs(medium["cohens_d"]) < 0.8
-
-
-def test_signo_positivo_cuando_a_mayor_que_b():
-    out = effect_size_cohens_d([10, 12, 14, 16], [1, 2, 3, 4])
-    assert out["cohens_d"] > 0
-    assert out["interpretation"] == "large"
-
-
-def test_varianza_cero_no_lanza():
-    out = effect_size_cohens_d([5, 5, 5], [5, 5, 5])
-    assert math.isnan(out["cohens_d"])
-    assert math.isnan(out["hedges_g"])
-    assert out["interpretation"] == "undefined"
-    assert out["pooled_sd"] == 0.0
-    assert "note" in out
-    assert "varianza cero" in out["note"]
-
-
-def test_n_insuficiente_no_lanza():
-    out = effect_size_cohens_d([3], [1, 2, 3])
-    assert math.isnan(out["cohens_d"])
-    assert math.isnan(out["hedges_g"])
-    assert out["interpretation"] == "undefined"
-    assert out["n_a"] == 1
-    assert out["n_b"] == 3
-    assert "note" in out
-
-
-def test_listas_vacias_no_lanza():
-    out = effect_size_cohens_d([], [])
-    assert math.isnan(out["cohens_d"])
-    assert math.isnan(out["hedges_g"])
-    assert out["interpretation"] == "undefined"
-    assert out["n_a"] == 0
-    assert out["n_b"] == 0
-    assert "note" in out
-
-
-def test_un_grupo_vacio_no_lanza():
-    out = effect_size_cohens_d([1, 2, 3], [])
-    assert math.isnan(out["cohens_d"])
-    assert out["interpretation"] == "undefined"
-    assert out["n_b"] == 0
-    assert "note" in out
@@ -3,19 +3,19 @@ name: fdr_correction
 kind: function
 lang: py
 domain: datascience
-version: "1.1.0"
+version: "1.0.0"
 purity: pure
 signature: "def fdr_correction(pvalues: list, alpha: float = 0.05, method: str = \"bh\") -> dict"
-description: "Correccion de comparaciones multiples (multiple-testing) sobre una lista de p-valores: Benjamini-Hochberg (FDR, 'bh'), Bonferroni (FWER, 'bonferroni') o Holm-Bonferroni (FWER step-down, 'holm', mas potente que Bonferroni simple). Antidoto al sesgo de mineria de datos (data-mining bias): al evaluar muchas hipotesis a la vez (todos los pares de una matriz), el azar produce falsos positivos; esta funcion ajusta los p-valores y marca cuales siguen siendo significativos tras corregir. Pura, sin dependencias externas, alineada 1:1 con la entrada (admite None en posiciones sin test)."
-tags: [eda, statistics, multiple-testing, fdr, benjamini-hochberg, bonferroni, holm, holm-bonferroni, fwer, p-value, data-mining-bias, python]
+description: "Correccion de comparaciones multiples (multiple-testing) sobre una lista de p-valores: Benjamini-Hochberg (FDR, 'bh') o Bonferroni (FWER, 'bonferroni'). Antidoto al sesgo de mineria de datos (data-mining bias): al evaluar muchas hipotesis a la vez (todos los pares de una matriz), el azar produce falsos positivos; esta funcion ajusta los p-valores y marca cuales siguen siendo significativos tras corregir. Pura, sin dependencias externas, alineada 1:1 con la entrada (admite None en posiciones sin test)."
+tags: [eda, statistics, multiple-testing, fdr, benjamini-hochberg, bonferroni, p-value, data-mining-bias, python]
 params:
  - name: pvalues
    desc: "lista de p-valores (floats en [0, 1]). Se admiten None u otros valores no validos en posiciones sin test disponible; se propagan como None en la salida y no cuentan como prueba (m)."
  - name: alpha
    desc: "nivel de significancia objetivo tras la correccion (default 0.05). Para BH es el umbral del FDR; para Bonferroni, del FWER (tasa de error por familia)."
  - name: method
-    desc: "'bh' = Benjamini-Hochberg (controla FDR, menos conservador, mas potencia); 'bonferroni' = controla FWER (mas conservador); 'holm' = Holm-Bonferroni (controla FWER, step-down, uniformemente mas potente que Bonferroni simple). Cualquier otro valor devuelve un dict con note."
-output: "dict {p_values_adjusted: lista alineada con pvalues (float ajustado o None), reject: lista de bool (True = significativo tras corregir), n_tests: nº de p-valores validos (m), n_rejected: nº de hipotesis rechazadas, alpha: float aplicado, method: str ('bh' | 'bonferroni' | 'holm')}. Casos degenerados (vacio, sin p validos, metodo desconocido) anaden clave note. Nunca None ni excepcion."
+    desc: "'bh' = Benjamini-Hochberg (controla FDR, menos conservador, mas potencia); 'bonferroni' = controla FWER (mas conservador). Cualquier otro valor devuelve un dict con note."
+output: "dict {p_values_adjusted: lista alineada con pvalues (float ajustado o None), reject: lista de bool (True = significativo tras corregir), n_tests: nº de p-valores validos (m), n_rejected: nº de hipotesis rechazadas, alpha: float aplicado, method: str}. Casos degenerados (vacio, sin p validos, metodo desconocido) anaden clave note. Nunca None ni excepcion."
 uses_functions: []
 uses_types: []
 returns: []
@@ -23,7 +23,7 @@ returns_optional: false
 error_type: ""
 imports: [math]
 tested: true
-tests: ["test_bh_golden_rechaza_dos_de_tres", "test_bonferroni_mas_conservador_que_bh", "test_p_values_adjusted_alineados_y_en_rango", "test_none_se_propaga_alineado", "test_lista_vacia_devuelve_note", "test_solo_none_devuelve_note", "test_metodo_desconocido_devuelve_note", "test_todos_significativos", "test_holm_golden_rechaza_dos_de_cuatro", "test_holm_entre_bonferroni_y_bh", "test_none_se_propaga_alineado_holm", "test_lista_vacia_holm_devuelve_note"]
+tests: ["test_bh_golden_rechaza_dos_de_tres", "test_bonferroni_mas_conservador_que_bh", "test_p_values_adjusted_alineados_y_en_rango", "test_none_se_propaga_alineado", "test_lista_vacia_devuelve_note", "test_solo_none_devuelve_note", "test_metodo_desconocido_devuelve_note", "test_todos_significativos"]
 test_file_path: "python/functions/datascience/fdr_correction_test.py"
 file_path: "python/functions/datascience/fdr_correction.py"
 ---
@@ -45,13 +45,6 @@ bon = fdr_correction(pvalues, alpha=0.05, method="bonferroni")
 print(bon["reject"])       # -> [True, False, False]
 print(bon["p_values_adjusted"])  # -> [0.03, 0.06, 1.0]

-# Holm-Bonferroni (step-down): controla el FWER como Bonferroni pero es mas
-# potente; rechaza al menos tanto como Bonferroni simple, nunca menos.
-holm = fdr_correction([0.01, 0.04, 0.03, 0.005], alpha=0.05, method="holm")
-print(holm["reject"])      # -> [True, False, False, True]
-print(holm["p_values_adjusted"])  # -> [0.03, 0.06, 0.06, 0.02]
-print(holm["n_rejected"])  # -> 2
-
 # Posiciones sin test (None) se propagan alineadas: el llamador puede pasar la
 # lista completa de pares y recuperar el mapeo 1:1.
 mix = fdr_correction([0.001, None, 0.9])
@@ -68,11 +61,8 @@ combinaciones y se quede con las que "pasan". Sin corregir, con N pruebas y
 alpha=0.05 esperas ~5% de falsos positivos *por azar*: cuantas mas pruebas, mas
 correlaciones espurias. Llama a `fdr_correction` con todos los p-valores de la
 familia y usa `reject` (no el umbral crudo) para decidir que es real. Usa `"bh"`
-por defecto (mejor potencia); `"holm"` (Holm-Bonferroni, FWER step-down) cuando
-quieras controlar el FWER pero sin la perdida de potencia de Bonferroni simple
-(rechaza al menos tanto como `"bonferroni"`, nunca menos); `"bonferroni"` cuando
-un falso positivo sea muy costoso y prefieras la maxima cautela del metodo mas
-simple.
+por defecto (mejor potencia); `"bonferroni"` cuando un falso positivo sea muy
+costoso y prefieras maxima cautela.

 ## Gotchas

@@ -86,16 +76,8 @@ simple.
  eso puedes pasar la lista completa de pares aunque algunos no tengan test.
 - `n_tests` es el numero de p-valores **validos** (m), que puede ser menor que
  `len(pvalues)` si hay `None`.
- BH controla cosa distinta que Bonferroni/Holm: BH la tasa de falsos
-  descubrimientos (FDR); Bonferroni y Holm la probabilidad de *cualquier* falso
+- BH y Bonferroni controlan cosas distintas: BH la tasa de falsos
+  descubrimientos (FDR), Bonferroni la probabilidad de *cualquier* falso
  positivo (FWER). No son intercambiables; elige segun el coste de equivocarte.
- `"holm"` y `"bonferroni"` controlan ambos el FWER, pero Holm es step-down y
-  uniformemente mas potente: rechaza al menos tantas hipotesis como Bonferroni
-  simple sobre el mismo set, nunca menos. Si controlas FWER, `"holm"` domina a
-  `"bonferroni"` salvo que necesites el ajuste mas simple por interpretabilidad.
 - Metodo desconocido o lista vacia/sin p validos no lanzan: devuelven un dict
-  con `note`. Los metodos validos son `"bh"`, `"bonferroni"` y `"holm"`.
-
-## Capability growth log
-
- v1.1.0 (2026-06-30) — añade method="holm" (Holm-Bonferroni step-down, FWER, más potente que Bonferroni simple).
+  con `note`.
@@ -5,15 +5,12 @@ todos los pares de una matriz de asociacion), la probabilidad de obtener al meno
 un falso positivo por azar crece con el numero de pruebas: es el sesgo de mineria
 de datos (data-mining bias) descrito por Aronson en *Evidence-Based Technical
 Analysis* (cap. 6). Esta funcion ajusta los p-valores para controlar ese sesgo
-mediante tres metodos clasicos:
+mediante dos metodos clasicos:

 - Benjamini-Hochberg (``"bh"``): controla la tasa de falsos descubrimientos
  (False Discovery Rate, FDR). Menos conservador, mas potencia estadistica.
 - Bonferroni (``"bonferroni"``): controla la tasa de error por familia
  (Family-Wise Error Rate, FWER). Mas conservador.
- Holm-Bonferroni (``"holm"``): controla el FWER como Bonferroni pero es un
-  procedimiento step-down uniformemente mas potente; rechaza al menos tantas
-  hipotesis como Bonferroni simple, nunca menos.

 No usa dependencias externas: aritmetica de la libreria estandar.
 """
@@ -38,9 +35,8 @@ def _is_valid_p(v) -> bool:
 def fdr_correction(pvalues: list, alpha: float = 0.05, method: str = "bh") -> dict:
    """Corrige una lista de p-valores por comparaciones multiples.

-    Aplica Benjamini-Hochberg (FDR), Bonferroni (FWER) o Holm-Bonferroni
-    (FWER, step-down) sobre ``pvalues`` y devuelve, alineado posicion a
-    posicion con la entrada, el p-valor ajustado y
+    Aplica Benjamini-Hochberg (FDR) o Bonferroni (FWER) sobre ``pvalues`` y
+    devuelve, alineado posicion a posicion con la entrada, el p-valor ajustado y
    si cada hipotesis se rechaza al nivel ``alpha`` tras la correccion. Las
    posiciones cuyo valor no sea un p-valor valido (``None``, ``NaN``, fuera de
    ``[0, 1]`` o no numerico) se conservan en la salida como ``None`` /
@@ -57,10 +53,8 @@ def fdr_correction(pvalues: list, alpha: float = 0.05, method: str = "bh") -> di
            otros valores no validos en posiciones sin test disponible; se
            propagan como ``None`` en la salida y no cuentan como prueba.
        alpha: nivel de significancia objetivo tras la correccion (default 0.05).
-            Para BH es el umbral del FDR; para Bonferroni y Holm, del FWER.
-        method: ``"bh"`` (Benjamini-Hochberg, FDR), ``"bonferroni"`` (FWER) o
-            ``"holm"`` (Holm-Bonferroni, FWER step-down, mas potente que
-            Bonferroni simple).
+            Para BH es el umbral del FDR; para Bonferroni, del FWER.
+        method: ``"bh"`` (Benjamini-Hochberg, FDR) o ``"bonferroni"`` (FWER).

    Returns:
        dict con las claves:
@@ -74,7 +68,7 @@ def fdr_correction(pvalues: list, alpha: float = 0.05, method: str = "bh") -> di
            n_tests: numero de p-valores validos usados en la correccion (m).
            n_rejected: numero de hipotesis rechazadas (significativas).
            alpha: nivel de significancia aplicado (float).
-            method: metodo aplicado (``"bh"``, ``"bonferroni"`` o ``"holm"``).
+            method: metodo aplicado (``"bh"`` o ``"bonferroni"``).

        Casos degenerados (lista vacia, sin p-valores validos o metodo
        desconocido) anaden ademas una clave ``note`` y devuelven listas
@@ -82,7 +76,7 @@ def fdr_correction(pvalues: list, alpha: float = 0.05, method: str = "bh") -> di
        en las posiciones invalidas).
    """
    method_norm = (method or "").strip().lower()
-    if method_norm not in {"bh", "bonferroni", "holm"}:
+    if method_norm not in {"bh", "bonferroni"}:
        n = len(pvalues)
        return {
            "p_values_adjusted": [None] * n,
@@ -92,8 +86,8 @@ def fdr_correction(pvalues: list, alpha: float = 0.05, method: str = "bh") -> di
            "alpha": float(alpha),
            "method": method,
            "note": (
-                f"metodo desconocido '{method}'; usa 'bh' (Benjamini-Hochberg), "
-                "'bonferroni' o 'holm' (Holm-Bonferroni)"
+                f"metodo desconocido '{method}'; usa 'bh' (Benjamini-Hochberg) "
+                "o 'bonferroni'"
            ),
        }

@@ -135,20 +129,6 @@ def fdr_correction(pvalues: list, alpha: float = 0.05, method: str = "bh") -> di
            padj = min(1.0, p * m)
            adjusted[orig_idx] = padj
            reject[orig_idx] = padj <= a
-    elif method_norm == "holm":
-        # Holm-Bonferroni (step-down). Ordena p ascendente; para el rank k
-        # (1-indexed) el p ajustado crudo es (m - k + 1) * p_(k). Impon
-        # monotonicidad acumulada (no decreciente) recorriendo de menor a mayor:
-        # padj_(k) = max(padj_(k-1), min(1, (m-k+1)*p_(k))), con padj_(0)=0.
-        order = sorted(valid, key=lambda t: t[1])  # [(orig_idx, p), ...] por p asc
-        prev = 0.0
-        for k in range(1, m + 1):
-            orig_idx, p = order[k - 1]
-            raw = min(1.0, (m - k + 1) * p)
-            padj = max(prev, raw)
-            prev = padj
-            adjusted[orig_idx] = padj
-            reject[orig_idx] = padj <= a
    else:
        # Benjamini-Hochberg (step-up). Ordena p ascendente y calcula q-valores
        # con la monotonicidad acumulada de derecha a izquierda.
@@ -82,8 +82,7 @@ def test_solo_none_devuelve_note():


 def test_metodo_desconocido_devuelve_note():
-    # 'holm' ya es un metodo valido (v1.1.0); usamos uno realmente desconocido.
-    out = fdr_correction([0.01, 0.02], method="sidak")
+    out = fdr_correction([0.01, 0.02], method="holm")
    assert "note" in out
    assert out["n_rejected"] == 0
    assert out["reject"] == [False, False]
@@ -98,66 +97,3 @@ def test_todos_significativos():
    assert bon["n_rejected"] == 3
    assert all(bh["reject"])
    assert all(bon["reject"])
-
-
-def test_holm_golden_rechaza_dos_de_cuatro():
-    # Holm-Bonferroni (step-down) sobre [0.01, 0.04, 0.03, 0.005], m=4, alpha=0.05.
-    # Ordenado ascendente: 0.005, 0.01, 0.03, 0.04.
-    #   padj_(1) = 4*0.005 = 0.02
-    #   padj_(2) = max(0.02, 3*0.01=0.03) = 0.03
-    #   padj_(3) = max(0.03, 2*0.03=0.06) = 0.06
-    #   padj_(4) = max(0.06, 1*0.04=0.04) = 0.06
-    # Mapeado al orden de entrada [0.01, 0.04, 0.03, 0.005]:
-    #   0.01 -> 0.03, 0.04 -> 0.06, 0.03 -> 0.06, 0.005 -> 0.02
-    out = fdr_correction([0.01, 0.04, 0.03, 0.005], alpha=0.05, method="holm")
-    assert out["method"] == "holm"
-    assert out["n_tests"] == 4
-    adj = out["p_values_adjusted"]
-    assert abs(adj[0] - 0.03) < 1e-9
-    assert abs(adj[1] - 0.06) < 1e-9
-    assert abs(adj[2] - 0.06) < 1e-9
-    assert abs(adj[3] - 0.02) < 1e-9
-    assert out["reject"] == [True, False, False, True]
-    assert out["n_rejected"] == 2
-
-
-def test_holm_entre_bonferroni_y_bh():
-    # Holm controla FWER como Bonferroni pero es step-down: rechaza AL MENOS
-    # tanto como Bonferroni simple, y a lo sumo tanto como BH (FDR, menos
-    # conservador). Cadena de potencia: bonferroni <= holm <= bh.
-    pvalues = [0.01, 0.02, 0.04, 0.005]
-    bon = fdr_correction(pvalues, alpha=0.05, method="bonferroni")
-    holm = fdr_correction(pvalues, alpha=0.05, method="holm")
-    bh = fdr_correction(pvalues, alpha=0.05, method="bh")
-    assert holm["n_rejected"] >= bon["n_rejected"]
-    assert holm["n_rejected"] <= bh["n_rejected"]
-    # En este set Holm gana potencia frente a Bonferroni simple (estricto).
-    assert holm["n_rejected"] > bon["n_rejected"]
-
-    # Un set donde Holm es estrictamente mas conservador que BH.
-    pvals2 = [0.01, 0.02, 0.03, 0.04]
-    bon2 = fdr_correction(pvals2, alpha=0.05, method="bonferroni")
-    holm2 = fdr_correction(pvals2, alpha=0.05, method="holm")
-    bh2 = fdr_correction(pvals2, alpha=0.05, method="bh")
-    assert holm2["n_rejected"] >= bon2["n_rejected"]
-    assert holm2["n_rejected"] < bh2["n_rejected"]
-
-
-def test_none_se_propaga_alineado_holm():
-    # None se propaga alineado tambien con holm: la posicion central no cuenta
-    # como prueba (m=2) y se devuelve como None / False.
-    out = fdr_correction([0.001, None, 0.9], method="holm")
-    assert out["n_tests"] == 2
-    assert out["p_values_adjusted"][1] is None
-    assert out["reject"][1] is False
-    assert out["reject"][0] is True
-    assert len(out["reject"]) == 3
-
-
-def test_lista_vacia_holm_devuelve_note():
-    out = fdr_correction([], method="holm")
-    assert out["p_values_adjusted"] == []
-    assert out["reject"] == []
-    assert out["n_tests"] == 0
-    assert out["n_rejected"] == 0
-    assert "note" in out
@@ -1,100 +0,0 @@
---
-name: preregister_hypothesis
-kind: function
-lang: py
-domain: datascience
-version: "1.0.0"
-purity: impure
-signature: "def preregister_hypothesis(paper_dir: str, hypotheses: dict, analysis_plan: dict) -> dict"
-description: "Pre-registra (congela) la hipotesis y el plan de analisis de un paper ANTES de mirar los datos: antidoto al HARKing (Hypothesizing After the Results are Known). Escribe/actualiza <paper_dir>/preregistration.md con un frontmatter (paper_slug, frozen_at, content_hash, status) y un cuerpo markdown DETERMINISTA derivado de (hypotheses, analysis_plan) (mismo input -> mismo cuerpo byte a byte, claves ordenadas alfabeticamente). El content_hash es sha256 del cuerpo NORMALIZADO (strip por linea + colapso de blancos), nunca del frontmatter. Una vez status=frozen es INMUTABLE: re-congelar con el mismo contenido es idempotente (no reescribe, devuelve unchanged) y re-congelar con contenido distinto se RECHAZA (no sobrescribe, devuelve error) para que no se pueda ajustar la hipotesis a los resultados. Estilo dict-no-throw: nunca lanza."
-tags: [papers, preregistration, reproducibility, anti-harking, python]
-params:
-  - name: paper_dir
-    desc: "ruta del directorio del paper, p.ej. 'papers/0001-mi-paper'. Debe existir (no se crea aqui). El paper_slug del frontmatter es el basename del dir. Si no existe o no es str -> {status:error, path, note} sin crash ni creacion."
-  - name: hypotheses
-    desc: "dict de hipotesis, p.ej. {'h0': 'no hay diferencia ...', 'h1': 'el grupo A > grupo B ...'}. Se renderiza en la seccion '## Hypotheses' con una linea por clave, ordenadas alfabeticamente para determinismo."
-  - name: analysis_plan
-    desc: "dict con el plan de analisis, p.ej. {'test': 'welch_t_test', 'effect_size_metric': 'cohens_d', 'decision_rule': 'rechazar H0 si p<0.05 tras Holm y |d|>=0.5', 'planned_n': 100, 'multiple_correction': 'holm'}. Se renderiza en '## Analysis plan' con una linea por clave (ordenadas alfabeticamente). Acepta valores no-str (int, etc.)."
-output: "dict dict-no-throw (NUNCA lanza). status='frozen' cuando escribe el archivo por primera vez o congela un draft previo ({status, path, content_hash, frozen_at}). status='unchanged' cuando ya estaba frozen con el mismo content_hash: no reescribe y preserva el archivo byte-identico incl. el frozen_at original ({status, path, content_hash, frozen_at}). status='error' cuando paper_dir no existe, ya esta frozen con un hash distinto (rechazo anti-HARKing, no sobrescribe), inputs invalidos o error de I/O ({status, path, note, [content_hash]})."
-uses_functions: []
-uses_types: []
-returns: []
-returns_optional: false
-error_type: "error_go_core"
-imports: [hashlib]
-tested: true
-tests: ["test_golden_congela_y_escribe_archivo", "test_idempotente_mismo_input_no_reescribe", "test_inmutabilidad_anti_harking_rechaza_contenido_distinto", "test_error_paper_dir_inexistente_no_crash_no_crea"]
-test_file_path: "python/functions/datascience/preregister_hypothesis_test.py"
-file_path: "python/functions/datascience/preregister_hypothesis.py"
---
-
-## Ejemplo
-
-```python
-import os, tempfile
-from datascience import preregister_hypothesis
-
-# Un directorio de paper que ya existe.
-paper_dir = tempfile.mkdtemp(prefix="0001-")
-
-hypotheses = {
-    "h0": "no hay diferencia entre el grupo A y el grupo B",
-    "h1": "el grupo A tiene mayor conversion que el grupo B",
-}
-analysis_plan = {
-    "test": "welch_t_test",
-    "effect_size_metric": "cohens_d",
-    "decision_rule": "rechazar H0 si p<0.05 tras Holm y |d|>=0.5",
-    "planned_n": 100,
-    "multiple_correction": "holm",
-}
-
-# 1) Primera vez: congela y escribe <paper_dir>/preregistration.md
-r1 = preregister_hypothesis(paper_dir, hypotheses, analysis_plan)
-print(r1["status"])        # -> "frozen"
-print(r1["content_hash"])  # sha256 del cuerpo
-
-# 2) Mismo input: idempotente, no reescribe.
-r2 = preregister_hypothesis(paper_dir, hypotheses, analysis_plan)
-print(r2["status"])        # -> "unchanged"
-
-# 3) Cambiar la hipotesis tras congelar (HARKing): rechazado, archivo intacto.
-r3 = preregister_hypothesis(paper_dir, {"h0": "...", "h1": "otra cosa"}, analysis_plan)
-print(r3["status"])        # -> "error"
-```
-
-## Cuando usarla
-
-Llamala al ARRANCAR el analisis de un paper, antes de tocar los datos, para
-dejar por escrito (y firmado por hash) que vas a probar y como vas a decidir.
-Es el primer paso de un flujo reproducible: pre-registras la hipotesis y el plan
-(`test`, `effect_size_metric`, `decision_rule`, `planned_n`,
-`multiple_correction`), y solo despues corres el analisis y comparas con lo
-pre-registrado. Si mas tarde el analisis "descubre" otra hipotesis que encaja
-mejor con los datos, el pre-registro congelado deja en evidencia el cambio: no se
-puede reescribir. Combinala con `effect_size_cohens_d` y `fdr_correction` para
-cerrar el plan declarado (effect size + correccion de multiples comparaciones).
-
-## Gotchas
-
- **Inmutabilidad (el corazon)**: una vez `status: frozen`, el pre-registro NO se
-  puede editar. Re-congelar con el MISMO contenido es idempotente (`unchanged`,
-  no reescribe, preserva incluso el `frozen_at` original). Re-congelar con
-  contenido DISTINTO devuelve `error` y deja el archivo intacto: asi se mata el
-  HARKing. Para cambiar de verdad la hipotesis hay que borrar el archivo a mano y
-  asumir explicitamente que ya no es un pre-registro valido.
- **dict-no-throw**: la funcion NUNCA lanza. Cualquier error previsible
-  (directorio inexistente, inputs no-dict, fallo de I/O, excepcion inesperada) se
-  captura y se devuelve como `{"status": "error", "note": ...}`. Siempre incluye
-  `path` (la ruta esperada del `preregistration.md`).
- **El hash es SOLO del cuerpo, nunca del frontmatter**: el frontmatter contiene
-  el propio `content_hash` y el `frozen_at` (timestamp), asi que incluirlos en el
-  hash seria circular y romperia la idempotencia. El cuerpo se normaliza antes de
-  hashear (strip por linea + colapso de lineas en blanco + strip final): cambios
-  irrelevantes de whitespace no alteran el hash, pero cambios de contenido SI.
- **Determinismo**: el cuerpo se genera con las claves de `hypotheses` y
-  `analysis_plan` ordenadas alfabeticamente, de modo que el orden de insercion del
-  dict no afecta al hash. Mismo `(hypotheses, analysis_plan)` -> mismo cuerpo y
-  mismo hash, byte a byte.
- **No crea el directorio del paper**: si `paper_dir` no existe, devuelve `error`
-  sin crear nada (ni el dir ni el archivo).
@@ -1,202 +0,0 @@
-"""Congela (pre-registra) la hipotesis y el plan de analisis de un paper.
-
-Anti-HARKing (Hypothesizing After the Results are Known): el pre-registro fija
-la hipotesis y el plan de analisis ANTES de mirar los datos. Una vez congelado
-(``status: frozen``) es INMUTABLE: cualquier intento posterior de re-congelar con
-un contenido distinto se RECHAZA en vez de sobrescribir, de modo que no se puede
-"ajustar" la hipotesis a los resultados despues de verlos.
-
-Escribe/actualiza ``<paper_dir>/preregistration.md`` con un frontmatter
-(``paper_slug``, ``frozen_at``, ``content_hash``, ``status``) y un cuerpo
-markdown DETERMINISTA derivado de ``(hypotheses, analysis_plan)``.
-
-Estilo dict-no-throw: NUNCA lanza; cualquier error previsible se captura y se
-devuelve como ``{"status": "error", "note": ...}``.
-"""
-
-import hashlib
-import os
-from datetime import datetime, timezone
-
-
-def _build_body(hypotheses: dict, analysis_plan: dict) -> str:
-    """Construye el cuerpo markdown del pre-registro de forma DETERMINISTA.
-
-    Mismo ``(hypotheses, analysis_plan)`` -> mismo cuerpo byte a byte. Las claves
-    se ordenan alfabeticamente para no depender del orden de insercion del dict.
-    """
-    lines = ["## Hypotheses", ""]
-    for k in sorted(hypotheses.keys()):
-        lines.append(f"- **{k}**: {hypotheses[k]}")
-    lines.append("")
-    lines.append("## Analysis plan")
-    lines.append("")
-    for k in sorted(analysis_plan.keys()):
-        lines.append(f"- **{k}**: {analysis_plan[k]}")
-    return "\n".join(lines)
-
-
-def _normalize(body: str) -> str:
-    """Normaliza el cuerpo para el hash: strip por linea + colapsa blancos.
-
-    Cambios irrelevantes de whitespace (espacios al final, dobles lineas en
-    blanco) no alteran el hash; cambios de contenido SI. Esto hace el hash
-    robusto sin perder la capacidad de detectar ediciones reales.
-    """
-    out = []
-    prev_blank = False
-    for raw in body.splitlines():
-        line = raw.strip()
-        if line == "":
-            if prev_blank:
-                continue
-            prev_blank = True
-        else:
-            prev_blank = False
-        out.append(line)
-    return "\n".join(out).strip()
-
-
-def _content_hash(body: str) -> str:
-    """sha256 hex del cuerpo NORMALIZADO (nunca del frontmatter)."""
-    return hashlib.sha256(_normalize(body).encode("utf-8")).hexdigest()
-
-
-def _parse_frontmatter(text: str) -> dict:
-    """Parsea el frontmatter ``--- ... ---`` simple (key: value) de un .md."""
-    if not text.startswith("---"):
-        return {}
-    parts = text.split("---", 2)
-    if len(parts) < 3:
-        return {}
-    fm = {}
-    for line in parts[1].splitlines():
-        line = line.strip()
-        if not line or ":" not in line:
-            continue
-        key, _, value = line.partition(":")
-        fm[key.strip()] = value.strip()
-    return fm
-
-
-def _render_file(slug: str, frozen_at: str, content_hash: str, body: str) -> str:
-    """Compone el archivo completo: frontmatter frozen + cuerpo."""
-    return (
-        "---\n"
-        f"paper_slug: {slug}\n"
-        f"frozen_at: {frozen_at}\n"
-        f"content_hash: {content_hash}\n"
-        "status: frozen\n"
-        "---\n"
-        "\n"
-        f"{body}\n"
-    )
-
-
-def preregister_hypothesis(paper_dir: str, hypotheses: dict, analysis_plan: dict) -> dict:
-    """Congela la hipotesis y el plan de analisis de un paper (anti-HARKing).
-
-    Escribe ``<paper_dir>/preregistration.md`` con frontmatter ``status: frozen``
-    y un cuerpo markdown determinista. Una vez congelado es inmutable.
-
-    Args:
-        paper_dir: ruta del directorio del paper (p.ej. ``"papers/0001-mi-paper"``).
-            El ``paper_slug`` es el basename del directorio. Debe existir.
-        hypotheses: dict de hipotesis, p.ej.
-            ``{"h0": "no hay diferencia ...", "h1": "grupo A > grupo B ..."}``.
-        analysis_plan: dict con el plan, p.ej.
-            ``{"test": "welch_t_test", "effect_size_metric": "cohens_d",
-            "decision_rule": "...", "planned_n": 100, "multiple_correction": "holm"}``.
-
-    Returns:
-        dict dict-no-throw (NUNCA lanza). Claves segun el caso:
-          - frozen:    {"status": "frozen", "path", "content_hash", "frozen_at"}
-          - unchanged: {"status": "unchanged", "path", "content_hash", "frozen_at"}
-          - error:     {"status": "error", "path", "note", ...}
-    """
-    expected_path = os.path.join(paper_dir, "preregistration.md")
-    try:
-        # 1) El directorio del paper debe existir; no se crea aqui.
-        if not isinstance(paper_dir, str) or not os.path.isdir(paper_dir):
-            return {
-                "status": "error",
-                "path": expected_path,
-                "note": f"paper_dir no existe: {paper_dir}",
-            }
-
-        if not isinstance(hypotheses, dict) or not isinstance(analysis_plan, dict):
-            return {
-                "status": "error",
-                "path": expected_path,
-                "note": "hypotheses y analysis_plan deben ser dict",
-            }
-
-        slug = os.path.basename(os.path.normpath(paper_dir))
-
-        # 2) + 3) Cuerpo determinista y su hash (solo del cuerpo, no del frontmatter).
-        body = _build_body(hypotheses, analysis_plan)
-        new_hash = _content_hash(body)
-
-        # 5) Logica de escritura.
-        if os.path.exists(expected_path):
-            existing = ""
-            try:
-                with open(expected_path, "r", encoding="utf-8") as fh:
-                    existing = fh.read()
-            except OSError as exc:
-                return {
-                    "status": "error",
-                    "path": expected_path,
-                    "note": f"no se pudo leer el pre-registro existente: {exc}",
-                }
-            fm = _parse_frontmatter(existing)
-            old_status = fm.get("status", "")
-            old_hash = fm.get("content_hash", "")
-            old_frozen_at = fm.get("frozen_at", "")
-
-            if old_status == "frozen":
-                if old_hash == new_hash:
-                    # Idempotente: mismo contenido ya congelado. No se reescribe.
-                    return {
-                        "status": "unchanged",
-                        "path": expected_path,
-                        "content_hash": new_hash,
-                        "frozen_at": old_frozen_at,
-                    }
-                # Inmutabilidad: ya congelado con OTRO hash -> se rechaza (anti-HARKing).
-                return {
-                    "status": "error",
-                    "path": expected_path,
-                    "content_hash": new_hash,
-                    "note": (
-                        "pre-registro inmutable: ya esta congelado (frozen) con un "
-                        "hash distinto; un pre-registro no se puede editar tras "
-                        "congelarse"
-                    ),
-                }
-            # status != "frozen" (p.ej. draft) -> se congela ahora.
-
-        # Archivo nuevo o draft existente: congelar con timestamp actual.
-        frozen_at = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
-        file_text = _render_file(slug, frozen_at, new_hash, body)
-        try:
-            with open(expected_path, "w", encoding="utf-8") as fh:
-                fh.write(file_text)
-        except OSError as exc:
-            return {
-                "status": "error",
-                "path": expected_path,
-                "note": f"no se pudo escribir el pre-registro: {exc}",
-            }
-        return {
-            "status": "frozen",
-            "path": expected_path,
-            "content_hash": new_hash,
-            "frozen_at": frozen_at,
-        }
-    except Exception as exc:  # noqa: BLE001 - dict-no-throw: nunca propagar.
-        return {
-            "status": "error",
-            "path": expected_path,
-            "note": f"error inesperado: {exc}",
-        }
@@ -1,99 +0,0 @@
-"""Tests para preregister_hypothesis (pre-registro inmutable, anti-HARKing).
-
-Importa el modulo hoja directamente (`preregister_hypothesis`) para no depender
-de que el paquete reexporte la funcion en su __init__ (lo integra el orquestador
-al cerrar el grupo papers). El pytest del repo resuelve el modulo hoja por su
-nombre directo.
-
-Todos los tests son hermeticos y deterministas: usan el fixture `tmp_path` de
-pytest; NUNCA escriben en `papers/`.
-"""
-
-from preregister_hypothesis import preregister_hypothesis
-
-
-def _parse_frontmatter(text: str) -> dict:
-    parts = text.split("---", 2)
-    fm = {}
-    for line in parts[1].splitlines():
-        line = line.strip()
-        if not line or ":" not in line:
-            continue
-        key, _, value = line.partition(":")
-        fm[key.strip()] = value.strip()
-    return fm
-
-
-HYP = {"h0": "no hay diferencia entre A y B", "h1": "el grupo A > grupo B"}
-PLAN = {
-    "test": "welch_t_test",
-    "effect_size_metric": "cohens_d",
-    "decision_rule": "rechazar H0 si p<0.05 tras Holm y |d|>=0.5",
-    "planned_n": 100,
-    "multiple_correction": "holm",
-}
-
-
-def test_golden_congela_y_escribe_archivo(tmp_path):
-    paper = tmp_path / "0001-x"
-    paper.mkdir()
-
-    res = preregister_hypothesis(str(paper), HYP, PLAN)
-
-    assert res["status"] == "frozen"
-    pre = paper / "preregistration.md"
-    assert pre.exists()
-
-    text = pre.read_text(encoding="utf-8")
-    fm = _parse_frontmatter(text)
-    assert fm["status"] == "frozen"
-    assert fm["paper_slug"] == "0001-x"
-    assert fm["content_hash"]  # no vacio
-    assert fm["frozen_at"]     # no vacio
-    assert res["content_hash"] == fm["content_hash"]
-    assert res["frozen_at"] == fm["frozen_at"]
-
-
-def test_idempotente_mismo_input_no_reescribe(tmp_path):
-    paper = tmp_path / "0001-x"
-    paper.mkdir()
-    pre = paper / "preregistration.md"
-
-    first = preregister_hypothesis(str(paper), HYP, PLAN)
-    assert first["status"] == "frozen"
-    bytes_before = pre.read_bytes()
-
-    second = preregister_hypothesis(str(paper), HYP, PLAN)
-    assert second["status"] == "unchanged"
-    # Mismo hash y frozen_at original preservado.
-    assert second["content_hash"] == first["content_hash"]
-    assert second["frozen_at"] == first["frozen_at"]
-    # El archivo NO cambio byte a byte (incl. frozen_at).
-    assert pre.read_bytes() == bytes_before
-
-
-def test_inmutabilidad_anti_harking_rechaza_contenido_distinto(tmp_path):
-    paper = tmp_path / "0001-x"
-    paper.mkdir()
-    pre = paper / "preregistration.md"
-
-    preregister_hypothesis(str(paper), HYP, PLAN)
-    bytes_frozen = pre.read_bytes()
-
-    # Intento de re-congelar con una hipotesis DISTINTA (HARKing) -> rechazado.
-    hyp_tramposo = {"h0": "no hay diferencia", "h1": "el grupo B > grupo A (cambiado tras ver datos)"}
-    res = preregister_hypothesis(str(paper), hyp_tramposo, PLAN)
-
-    assert res["status"] == "error"
-    # Asercion mas importante: el archivo en disco SIGUE siendo el original.
-    assert pre.read_bytes() == bytes_frozen
-
-
-def test_error_paper_dir_inexistente_no_crash_no_crea(tmp_path):
-    missing = tmp_path / "no-existe"
-    res = preregister_hypothesis(str(missing), HYP, PLAN)
-
-    assert res["status"] == "error"
-    # No se creo el directorio ni el archivo.
-    assert not missing.exists()
-    assert not (missing / "preregistration.md").exists()