feat(infra): auto-commit con 29 cambios

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

docs/adr/0004-telemetry-driven-capability-growth.md

@@ -0,0 +1,83 @@
+# ADR 0004 — Telemetria de ejecuciones de Claude como motor de crecimiento del registry
+
+- **Fecha:** 2026-05-14
+- **Estado:** accepted
+- **Relacionados:** issue 0085 (telemetry + call_monitor), issue 0086 (delegation + capability groups), issue 0087 (capability discovery acceleration)
+
+## Contexto
+
+Hasta 0085, el registry crecia "manualmente": el humano (o Claude bajo supervision) detectaba patrones repetidos, redactaba proposals y un agente los implementaba. Costes observados en sesiones reales:
+
+- Claude reinventaba inline logica que ya existia como funcion. Caso reciente (2026-05-13/14): `taskkill + cp Desktop + cmd /c start` ejecutado 5 veces seguidas pese a que `deploy_cpp_exe_to_windows_bash_infra` ya cubria el caso.
+- Funciones recien creadas quedaban huerfanas (`calls_90d=0`) porque Claude no las encontraba via FTS5 con queries genericas.
+- Tres pasos del bucle reactivo (`MEJORAR → APROBAR → CONSTRUIR`) requerian humano en el loop incluso para gaps obvios.
+
+Sin medir lo que el agente realmente hace, las reglas (`registry_first.md`, `delegation.md`) son aspiracion no auditable. **No se puede mejorar lo que no se mide.**
+
+## Decision
+
+Tratar las **ejecuciones de Claude como senal de primera clase** del registry. Tres componentes encadenados:
+
+1. **Capturar todo** (issue 0085) — Hook `PostToolUse` parsea cada Bash + cada `mcp__registry__*` y persiste en `projects/fn_monitoring/apps/call_monitor/operations.db`. Tablas: `calls`, `code_writes`, `test_runs`, `e2e_runs_fn`, `violations`, `patterns`, `sessions`. Vista `function_stats` agrega por `function_id`.
+
+2. **Agrupar por capability** (issue 0086) — Tags planos (`notebook`, `metabase`, `deploy`, `cpp-windows`, ...) sobre funciones afines + pagina madre `docs/capabilities/<grupo>.md` con lista, ejemplo canonico y fronteras. Cargar un grupo cuesta **1 read**, no N busquedas FTS5.
+
+3. **Acelerar descubrimiento** (issue 0087) — 5 capas escalonadas por coste de lookup:
+   - Top-20 + fresh-7d en bloque autogenerado de CLAUDE.md (coste 0, contexto base).
+   - Hook `UserPromptSubmit` injecta `FRESH:` / `TOP:` cada turno (coste 0).
+   - Hook `PreToolUse` con `fn_match` fuzzy FTS5 sugiere `USE: ./fn run <id>` mid-flight (coste <50ms).
+   - `docs/capabilities/<grupo>.md` cargado solo si tarea matchea dominio (coste 1 read).
+   - `MEMORY.md` con insights cross-session (coste 0, persistente).
+
+Las 3 metricas norte (en Monitor tab del `registry_dashboard`):
+
+- `Reg %` — fraccion de calls con `function_id != ''`. Sube cuando Claude usa registry en vez de heredoc.
+- `MCP ratio` — fraccion de `tool_used IN (mcp_*, fn_run)`. Mide adopcion canonica.
+- `violations_24h` — antipatrones detectados. Baja con cada vuelta del bucle.
+
+Cualquier decision tecnica que choque con estas metricas esta mal priorizada.
+
+## Alternativas consideradas
+
+- **Reglas mas estrictas sin telemetria.** Descartado: ya teniamos `registry_first.md` y se ignoraba sin que nada lo detectase. Reglas sin metricas son aspiracion.
+- **Auto-merge de proposals desde el bucle reactivo.** Descartado: el agente decide *que* construir, pero el humano sigue revisando antes de escribir codigo permanente. Limite duro en `/fn_claude`: max 5 funciones por invocacion, no push automatico.
+- **MCP-only sin hooks de telemetria.** Descartado: heredocs y `sqlite3` directo seguirian invisibles. El hook `PostToolUse` es la red de captura unica que cubre todos los canales (MCP, fn_run, heredoc, Edit, Write).
+- **Indice estatico (lista plana de IDs) en lugar de capability groups.** Descartado: una lista de 800 funciones no cabe en contexto. Grupos con pagina madre densa (~80 lineas) cubren 80% del trabajo con coste de lectura asumible.
+
+## Consecuencias
+
+### Nuevo (visible en este repo)
+
+- Carpeta `docs/capabilities/` con pagina madre por grupo. Indice en `docs/capabilities/INDEX.md`. Auditado por `fn doctor capabilities`.
+- Hook `UserPromptSubmit` injecta cada turno: `REGISTRY-FIRST` + `CAPABILITY-GROWTH: created_this_session=X used=Y orphan=Z`.
+- Hook `PostToolUse` (en `.claude/settings.local.json`) escribe a `call_monitor.operations.db`. Solo `args_hash`, NUNCA valores de argumentos (privacidad).
+- Slash command `/fn_claude` — auto-auditoria: detecta gaps en la sesion, lanza `fn-constructor` en paralelo, valida que la proxima sesion usara la nueva funcion.
+- Subagente `fn-constructor` mandatorio cuando se vaya a escribir >=5 lineas reutilizables inline.
+
+### Reglas nuevas / endurecidas
+
+- `.claude/rules/delegation.md` — STOP + spawn `fn-constructor` mismo turno, paralelo cuando >1 funcion independiente, tag de grupo obligatorio.
+- `.claude/rules/capability_groups.md` — convencion de tag plano + pagina madre + auditoria via `fn doctor capabilities`.
+- `.claude/rules/registry_calls.md` — 3 patrones canonicos (inspect / run / compose), antipatrones, excepciones para `sqlite3` directo.
+
+### Boundary explicito
+
+La telemetria cubre al **agente** y a **invocaciones canonicas**. Quedan fuera:
+
+- Funcion Go/C++ llamada internamente por app ya compilada.
+- Service de produccion recibiendo HTTP sin pasar por `fn run`.
+- Sub-agente (`Agent` tool) sin telemetria heredada (mitigado por env var `FN_TELEMETRY=1` propagada).
+
+Compensar runtime invisible con `e2e_checks` (issue 0068) y `fn doctor uses-functions` (audit estatico).
+
+### Riesgos asumidos
+
+- **Latencia de `fn_match` (capa 3).** Objetivo <50ms. Si supera 100ms, degradar a "solo en comandos largos" o "al final del turno".
+- **Falsos positivos en propuestas automaticas.** Limite duro: max 5 por invocacion, evidencia obligatoria (snippet real), sin auto-merge.
+- **Telemetria genera datos sensibles.** Mitigacion estructural: solo se guarda `args_hash`. Snippets de error redactados por allowlist.
+
+## Aprendizaje
+
+A 2026-05-14, primer grupo `cpp-windows` creado en respuesta directa al patron taskkill+cp+start repetido: `is_cpp_app_running_windows_bash_infra`, `launch_cpp_app_windows_bash_infra`, pipeline `redeploy_cpp_app_windows_bash_pipelines`, pagina madre `docs/capabilities/cpp-windows.md`. Validacion empirica del bucle: detectar -> construir -> agrupar -> documentar -> esperar reduccion de violations en proximas sesiones.
+
+Pendiente: medir el delta de `Reg %` y `violations_24h` a 7d para confirmar que el coste de descubrimiento bajo de "FTS5 N veces" a "1 read de pagina madre".

docs/adr/README.md

@@ -59,3 +59,6 @@ Qué se aprendió después. Útil cuando un ADR se supersede.
 | # | Título | Estado |
 |---|--------|--------|
 | [0001](0001-gitbutler-experiment.md) | Experimento con GitButler para trabajo paralelo | rejected |
+| [0002](0002-apps-analyses-as-dataforge-master.md) | Apps y analyses como sub-repos `dataforge/<name>` con branch master | accepted |
+| [0003](0003-orphan-tu-as-separate-function-entry.md) | TU adicional de un parent function como entrada propia | accepted |
+| [0004](0004-telemetry-driven-capability-growth.md) | Telemetria de ejecuciones de Claude como motor de crecimiento del registry | accepted |

docs/capabilities/INDEX.md

@@ -21,6 +21,7 @@ Indice de grupos de capacidades del registry. Cada grupo agrupa >=3 funciones qu
 | [metabase](metabase.md) | 106 | _(editar — promovido automaticamente)_ |
 | [doctor](doctor.md) | 11 | Diagnostico read-only del registry: artefactos, servicios, drift, funciones huerfanas |
 | [notebook](notebook.md) | 5 | Operar Jupyter Lab colaborativo (discover/read/exec/write/kernel) |
+| [cpp-windows](cpp-windows.md) | 7 | Compilar, desplegar, lanzar y verificar apps C++ en Windows desde WSL2 |
 
 ## Como anadir grupo
 

docs/capabilities/cpp-windows.md

@@ -0,0 +1,80 @@
+# cpp-windows
+
+Operar apps C++ del registry en Windows desde WSL2: compilar, desplegar, lanzar, verificar y relanzar.
+
+## Funciones del grupo
+
+| ID | Firma corta | Que hace |
+|---|---|---|
+| `build_cpp_windows_bash_infra` | `build_cpp_windows([target])` | Cross-compila apps C++ para Windows con mingw-w64 |
+| `deploy_cpp_exe_to_windows_bash_infra` | `deploy_cpp_exe_to_windows(app_name, app_dir)` | Copia .exe + DLLs + assets al Desktop Windows, mata proceso previo |
+| `launch_cpp_app_windows_bash_infra` | `launch_cpp_app_windows(app_name, [desktop_dir])` | Lanza .exe en Windows via cmd.exe /c start, retorna inmediatamente |
+| `is_cpp_app_running_windows_bash_infra` | `is_cpp_app_running_windows(app_name)` | Exit 0 si el proceso esta vivo (tasklist.exe), stdout: `RUNNING: PID=N MEM=...K` |
+| `launch_cpp_app_windows_bash_infra` | `launch_cpp_app_windows(app_name, [desktop_dir])` | Lanza .exe en Windows via cmd.exe /c start, retorna inmediatamente |
+| `e2e_run_cpp_windows_bash_infra` | `e2e_run_cpp_windows(target, [--no-build], [--no-deploy])` | Build + deploy + run headless de app C++ (tests e2e tipo altsnap) |
+| `redeploy_cpp_app_windows_bash_pipelines` | `redeploy_cpp_app_windows(app_name, app_dir, [--build])` | Pipeline completo: build? + deploy + launch + verify en un comando |
+
+## Ejemplo canonico
+
+### Redeploy rapido (build ya hecho)
+
+```bash
+source bash/functions/infra/deploy_cpp_exe_to_windows.sh
+source bash/functions/infra/launch_cpp_app_windows.sh
+source bash/functions/infra/is_cpp_app_running_windows.sh
+
+deploy_cpp_exe_to_windows "registry_dashboard" \
+    "/home/lucas/fn_registry/projects/fn_monitoring/apps/registry_dashboard"
+launch_cpp_app_windows "registry_dashboard"
+sleep 1
+if is_cpp_app_running_windows "registry_dashboard"; then
+    echo "OK: arrancado"
+else
+    echo "ERROR: no arranco" >&2; exit 1
+fi
+```
+
+### Via pipeline (un solo comando)
+
+```bash
+source bash/functions/pipelines/redeploy_cpp_app_windows.sh
+
+# Sin recompilar
+redeploy_cpp_app_windows "registry_dashboard" \
+    "/home/lucas/fn_registry/projects/fn_monitoring/apps/registry_dashboard"
+
+# Con recompilacion previa
+redeploy_cpp_app_windows "chart_demo" \
+    "/home/lucas/fn_registry/cpp/apps/chart_demo" --build
+```
+
+### Comprobar si esta vivo antes de decidir
+
+```bash
+source bash/functions/infra/is_cpp_app_running_windows.sh
+
+if is_cpp_app_running_windows "registry_dashboard"; then
+    echo "Ya esta corriendo — skip launch"
+else
+    launch_cpp_app_windows "registry_dashboard"
+fi
+```
+
+## Fronteras
+
+- No gestiona builds Linux ni assets de Linux — solo el flujo Windows.
+- No verifica que la app funcione correctamente, solo que el proceso existe (`tasklist.exe`).
+- No gestiona credenciales ni configuracion de la app — eso es responsabilidad de cada app via `local_files/`.
+- Tests automatizados en CI no son posibles — requieren WSL2 con Windows activo.
+
+## Prerequisitos
+
+- WSL2 con interop a Windows habilitado (`tasklist.exe`, `cmd.exe`, `wslpath` accesibles).
+- `mingw-w64` instalado en WSL para `build_cpp_windows` (`sudo apt install mingw-w64`).
+- El .exe compilado en `cpp/build/windows/apps/<app>/` antes de `deploy_cpp_exe_to_windows`.
+
+## Notas
+
+El flujo estandar es: `build_cpp_windows` → `deploy_cpp_exe_to_windows` → `launch_cpp_app_windows` → `is_cpp_app_running_windows`. El pipeline `redeploy_cpp_app_windows` encapsula los pasos 2-4 (con 1 opcional via `--build`).
+
+`deploy_cpp_exe_to_windows` ya incluye un `taskkill.exe` interno — no es necesario matar el proceso manualmente antes de llamarlo. `is_cpp_app_running_windows` es util cuando se quiere tomar la decision de matar/no matar de forma explicita antes del deploy.

docs/diary/2026-05-14.md

@@ -0,0 +1,103 @@
+# 2026-05-14
+
+## 01:35 — Telemetria de Claude como motor de capacidades + grupo cpp-windows
+
+El registry pasa a optimizarse sobre las propias ejecuciones del agente. Cada Bash, MCP call y heredoc queda capturado en `call_monitor.operations.db` (issue 0085) y alimenta el bucle: detectar patron inline -> proponer funcion -> agrupar en capability -> servir descubrimiento gratis al siguiente turno.
+
+- Hecho: ADR 0004 `0004-telemetry-driven-capability-growth.md` aceptado — formaliza el bucle telemetria + capability groups + discovery acceleration.
+- Hecho: Indice ADR `docs/adr/README.md` ahora lista 0001..0004 (faltaban 0002 y 0003).
+- Hecho: Grupo de capacidades `cpp-windows` creado como caso piloto del bucle:
+  - `bash/functions/infra/is_cpp_app_running_windows.sh` + `.md` — `is_cpp_app_running_windows_bash_infra`.
+  - `bash/functions/infra/launch_cpp_app_windows.sh` + `.md` — `launch_cpp_app_windows_bash_infra`.
+  - `bash/functions/pipelines/redeploy_cpp_app_windows.sh` + `.md` — `redeploy_cpp_app_windows_bash_pipelines` (build? + deploy + launch + verify).
+  - Pagina madre `docs/capabilities/cpp-windows.md` con lista, ejemplo canonico y fronteras.
+  - Fila anadida a `docs/capabilities/INDEX.md`.
+- Hecho: Issue `dev/issues/0087-capability-discovery-acceleration.md` con modelo de 5 capas + plan en 3 tandas (A paralelo, B dependiente, C refuerzos).
+- Hecho: Slash command `/fn_claude` (`.claude/commands/fn_claude.md`) describe AUDIT -> GAP -> PROPOSE -> CONSTRUCT -> VALIDATE -> SELF-TEST como flujo autonomo. Limite duro max 5 funciones por invocacion, sin auto-merge.
+- Hecho: `.claude/CLAUDE.md` raiz lleva ahora seccion "Delegacion + Capability Groups" como REGLA DURA (issue 0086).
+
+### Por que ahora
+
+Sesion 2026-05-13/14: Claude reinvento `taskkill + cp Desktop + cmd /c start` cinco veces pese a tener `deploy_cpp_exe_to_windows_bash_infra`. Evidencia directa de que sin telemetria + descubrimiento barato las reglas son aspiracion. La respuesta no es regla mas estricta, es **infraestructura para que la regla se cumpla**.
+
+### Las 3 metricas norte (Monitor tab del `registry_dashboard`)
+
+- `Reg %` — fraccion de calls con `function_id != ''`. Sube cuando se usa registry.
+- `MCP ratio` — adopcion de patrones canonicos.
+- `violations_24h` — antipatrones detectados. Baja cuando el bucle cierra.
+
+### Pendiente
+
+- Implementar Tanda A de 0087 en paralelo: `fn doctor capabilities --emit-claude-md`, binario `fn_match`, validator de IDs en `fn_create_function`, clausula hooks en `registry_calls.md`.
+- Medir delta `Reg %` y `violations_24h` a 7d. Si no se mueven, replantear capas 1-2.
+- Hook `PreToolUse` con `fn_match` requiere benchmark <50ms antes de habilitar global.
+
+Referencias: ADR 0004, issue 0085, issue 0086, issue 0087, `docs/capabilities/cpp-windows.md`.
+
+## 02:00 — Tandas A+B de issue 0087 cerradas + fn_match tuning + Failed Functions sub-tab
+
+### Tanda A (paralelo, 3 fn-constructor + edits directos)
+
+- `cmd/fn/match.go` — subcommand `fn match "<command>"`. Tokeniza comando, FTS5 query sobre `functions_fts`, re-score aditivo (name=+3, tags=+2, signature=+1.5, description=+1). Latencia 6-7ms. Devuelve `top[]` con `score` (normalizado top=1.0) y `raw_score` (absoluto pre-normalizacion). Bug fix critico: `high_confidence` ahora se computa sobre `raw_score`, no `score` — antes era SIEMPRE true por la normalizacion.
+- `cmd/fn/doctor.go` — flag `--emit-claude-md` en subcomando `capabilities`. Emite bloque markdown con secciones TOP 20 (por `calls_total`), Fresh 7d, Pipelines top 5. Fallback si `call_monitor.operations.db` ausente.
+- `functions/infra/emit_capabilities_md.go` — `EmitCapabilitiesMd` + `RenderCapabilitiesMd` (paquete `infra`).
+- `projects/fn_monitoring/apps/call_monitor/sequences.go` + `migrations/006_function_sequences.sql` — subcomando `call_monitor sequences --detect [--propose]`. Detecta secuencias A->B(->C) con: same session, gap < 30s, occ >= 5, sess >= 2, success_rate >= 0.9. Genera proposals `new_pipeline` con evidencia. 41 secuencias capturadas en primer run; 0 candidatas (umbrales no alcanzados todavia).
+- `.claude/rules/registry_calls.md` — clausula nueva: hooks e infraestructura de telemetria pueden leer `registry.db` directo con conexion read-only. NO sujeto a regla MCP-first porque no es accion del agente.
+- `.claude/rules/function_growth_and_self_docs.md` (nuevo) + fila en `INDEX.md` — contrato `.md` autosuficiente (Ejemplo + Cuando usarla + Gotchas + Growth log) + crecimiento del registry por **promocion de composiciones** (no por inflar funciones individuales). Issue 0087.
+- `.claude/CLAUDE.md` — Norte ampliado a 4 objetivos (anadido `PROMOVER COMPOSICIONES A PIPELINES`). Linea sobre auto-discovery zero-second-lookup.
+
+### Tanda B (3 general-purpose en paralelo)
+
+- `.claude/scripts/hook_fn_match.sh` (PreToolUse, Bash matcher) — denylist temprana (cmds < 20 chars, `ls/cd/pwd/cat/echo/grep`, `./fn run`, pure-cd). Llama `fn match` con `timeout 0.2`. Trigger: `high_confidence==true OR raw_score >= ~5`. Imprime `<system-reminder>FUZZY-MATCH: USE ./fn run <id>` a stderr. Latencia path trigger ~113ms, denylist ~32ms.
+- `.claude/scripts/hook_capabilities_inject.sh` (UserPromptSubmit) — cache `~/.cache/fn_registry/capabilities.txt` TTL 1h. Llama `fn doctor capabilities --emit-claude-md`, awk-parse 3 secciones, emite JSON `hookSpecificOutput.additionalContext` con linea compacta `CAPABILITIES (cache 1h): TOP / FRESH / PIPELINES`. Latencia cold 33ms, warm 18ms.
+- `~/.config/systemd/user/call_monitor_sequences.{service,timer}` + copias versionadas en `projects/fn_monitoring/apps/call_monitor/systemd/`. Timer OnCalendar `*-*-* 00/6:00:00` (cada 6h). Persistent=true. Service activo y verificado (exit 0).
+
+### Tuning de fn_match
+
+Tres iteraciones del threshold de `high_confidence`:
+
+- v1: `top1.score / top2.score > 1.5` (normalizado). Resultado: SIEMPRE true. Inutil.
+- v2: `raw_score >= 3.0`. Mejor pero deja falsos positivos en queries debiles (raw 3.2-3.65).
+- v3: `raw_score >= 5.0`. Mata caso ejemplar `taskkill` (raw 4.06). Demasiado estricto.
+- **v4 final**: `raw_score >= 4.0`. Balance ~93% precision contra patrones de `analysis/domain_coverage_gaps`. Prefer silencio en queries cortas; acepta 1 falso positivo conocido (`robots.txt user-agent` -> `agent_scaffold` por token "agent").
+
+### Dashboard updates (sub-repo `registry_dashboard`)
+
+- Migration 007 `projects/fn_monitoring/apps/call_monitor/migrations/007_calls_command_snippet.sql` — anade columna `command_snippet TEXT` a `calls`. Aditiva, idempotente. Solo se rellena cuando `function_id == ''`. Redactado de secrets (`password=`, `token=`, `secret=`, `api_key=`, `bearer=`) antes de persistir.
+- `.claude/scripts/hook_call_monitor.sh` — `insert_call` acepta 4to arg `snippet`. Solo escribe si `fn_id` vacio. Llamadores Bash pasan `CMD_HEAD` (200 chars).
+- Dashboard Recent Executions: columna `Function` muestra snippet `$ <cmd>` en gris cuando `function_id` vacio. Hover tooltip con snippet completo.
+- Nueva sub-tab `Failed Functions` (5a): subset de `recent_executions` con `function_id != '' AND !success`. Columnas When/Function/Tool/Error class/Error snippet. Util para diagnostico cuando objetivo 1+2 caen.
+- ImPlot scatter:
+  - Eje Y dinamico `0..max(visible) + 500ms` (rescale evita pillarse en picos viejos fuera de ventana).
+  - Combo `Scatter:` en toolbar (1m/5m/15m/1h/6h), independiente del filtro de KPIs.
+  - `ImPlot::GetStyle().UseLocalTime = true` — el eje X ahora muestra hora local, no UTC.
+  - `ImPlotAxisFlags_NoHighlight` en X y Y — sin iluminacion ruidosa al hover.
+  - Hover tooltip sobre punto: When, Function, Tool, Duration, Error (si fail).
+
+### Bug fix critico: launch_cpp_app_windows
+
+`cmd.exe /c "cd /d \"$dir\" && start \"$app\" \"$app.exe\""` rompia en cmd.exe — el `\"` final tras path termiando en `\` se interpretaba como escape de comilla, dejando string sin cerrar -> error "Windows cannot find \\". Fix: reescribir a PowerShell `Start-Process -FilePath ... -WorkingDirectory ...` que usa quoting simple literal.
+
+### Discovery quality (tests vs fn_monitoring/analysis/domain_coverage_gaps)
+
+Patrones del analysis testeados contra `fn match`:
+
+- Hits correctos `high=true`: sharpe ratio, monte carlo, cdp browse, websocket stream, stable diffusion, taskkill exe.
+- Falsos negativos coherentes `high=false`: binance kline, kelly criterion, VaR conditional, OLS regression, vectorized backtest, robots.txt -> coincide con gaps reales del analysis.
+- Falso positivo persistente: 1 de 14 (robots.txt -> agent_scaffold).
+- Cobertura validada: finance/browser/infra/ml estan cubiertos. Trading/quant/scraping confirmados como gaps reales del analysis.
+
+### Validacion end-to-end
+
+- PreToolUse hook test: `echo '{...taskkill...}' | bash .claude/scripts/hook_fn_match.sh` -> FUZZY-MATCH con `deploy_cpp_exe_to_windows`.
+- UserPromptSubmit hook: cada turno user injecta `CAPABILITIES (cache 1h): TOP / FRESH / PIPELINES`.
+- Timer: `systemctl --user list-timers` muestra proxima ejecucion. Manual run exit 0.
+- Pipeline `redeploy_cpp_app_windows` ejecutado 3+ veces esta sesion via `./fn run`. Reemplaza ~6 commands manuales con 1 invocacion.
+
+### Pendiente
+
+- 2 bugs cosmeticos no bloqueantes: `cp: Permission denied` benigno en deploy (rsync salva); `PID=RUNNING: PID=N MEM=K` formato raro en mensaje final del pipeline redeploy.
+- Tanda C de 0087 (refuerzos): `/fn_claude` auto-append a `MEMORY.md` al crear funciones, naming validator soft.
+- Esperar telemetria de 7d para medir delta `Reg %` y `violations_24h`. Si no se mueven, replantear capa 3 (interceptor PreToolUse mas agresivo).
+
+Referencias: ADR 0004, issues 0085/0086/0087, `.claude/rules/function_growth_and_self_docs.md`, `.claude/scripts/hook_{fn_match,capabilities_inject}.sh`, `cmd/fn/match.go`.