feat(infra): auto-commit con 29 cambios

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

.claude/CLAUDE.md

@@ -2,6 +2,19 @@
 
 Registry personal de codigo reutilizable con busqueda FTS. Diseñado para composicion funcional y agentes.
 
+## Objetivos del registry (Norte) — Issues 0086 + 0087
+
+**4 metricas optimizadas por el bucle reactivo** (visibles en Monitor tab del `registry_dashboard`):
+
+1. **MAXIMIZAR `Reg %`** — porcentaje de calls del agente que golpean una funcion del registry (`function_id != ''`). Cada bash inline o heredoc que reescribe logica baja el ratio. Target: subir cada semana.
+2. **MEJORAR uso del registry por Claude** — el agente debe encontrar y usar funciones existentes antes de escribir codigo. Indicadores: `MCP` (mcp/heredoc/fn run) sube; violations baja. Si Claude no encuentra una funcion por busqueda mediocre, mejorar `description`/`tags`/`params_schema` de esa funcion.
+3. **ACELERAR tareas comunes via funciones nuevas** — patrones inline repetidos >2 veces -> `fn-constructor` crea la funcion, Claude la usa el siguiente turno. Velocidad medida en pasos (turnos) por tarea. Pattern detection: tab Monitor + `mcp__registry__fn_proposal action="list"`.
+4. **PROMOVER COMPOSICIONES A PIPELINES** (issue 0087) — el registry no crece inflando funciones, crece **promoviendo secuencias A→B(→C) que se repiten con exito** a pipelines one-shot. Hoy `bank_login + bank_make_transfer` (2 calls). Manana `bank_transfer_oneshot` (1 call). Misma capacidad, mitad de pasos. Detectado por telemetria de secuencias en `call_monitor`. Una funcion que hace bien UNA cosa NO necesita crecer — lo que crece es el catalogo de composiciones probadas.
+
+**Auto-discovery zero-second-lookup:** cada `.md` debe ser autosuficiente — `## Ejemplo` lanzable + `## Cuando usarla` + `## Gotchas` (impuras). Descubrir = lanzar, sin segunda lectura. Ver `.claude/rules/function_growth_and_self_docs.md`.
+
+Cualquier decision tecnica que choque con estos objetivos esta mal priorizada. Ejemplo: un bash heredoc rapido hoy que reinventa logica = penaliza objetivos 1 y 3 manana.
+
 **Dos bases de datos SQLite:**
 - **registry.db** (raiz) — funciones, tipos, proposals, apps, projects, analysis, vaults, pc_locations. Regenerable con `fn index` (excepto proposals y pc_locations).
 - **operations.db** (por app en `apps/*/`) — entities, relations, executions, assertions. Datos vivos.

.claude/commands/fn_claude.md

@@ -6,6 +6,41 @@ description: "Auto-auditoria: verifica que la sesion registra uso de funciones,
 
 Comando meta: Claude se audita a si mismo. Verifica que su comportamiento en esta sesion (y las recientes) deja rastro en `call_monitor.operations.db`, detecta gaps reales del registry para el trabajo actual, lanza sub-agentes `fn-constructor` en paralelo para cerrar esos gaps, y verifica que la proxima vez usara las funciones nuevas.
 
+## Objetivos del registry (Norte) — Issues 0086 + 0087
+
+Cada corrida de `/fn_claude` optimiza 4 metricas visibles en Monitor tab del `registry_dashboard`:
+
+1. **MAXIMIZAR `Reg %`** — % de calls con `function_id != ''`. Cada heredoc/bash que reescribe logica baja el ratio. Target: subir cada semana.
+2. **MEJORAR uso del registry por Claude** — Claude busca y reusa antes de escribir. `MCP` (mcp/heredoc/fn run) sube, `violations` baja. Si una funcion existe pero Claude no la encuentra, mejorar su `description`/`tags`/`params_schema` (FTS indexa todo).
+3. **ACELERAR tareas comunes** — patrones inline repetidos >2x -> `fn-constructor` los convierte en funcion, Claude las usa el siguiente turno. Menos pasos por tarea = mas valor.
+4. **PROMOVER COMPOSICIONES A PIPELINES** (issue 0087) — el registry crece **promoviendo secuencias A->B(->C) que se repiten con exito** a pipelines one-shot. Una funcion que hace bien una cosa NO necesita crecer. Pattern detection: `call_monitor sequences --detect --propose` (cron 6h activo) + tab `Promotion candidates` del dashboard.
+
+Si `/fn_claude` no mueve estas 4 metricas, no esta haciendo su trabajo.
+
+## Infraestructura de discovery activa (issue 0087)
+
+Cada turno tienes capacidades ya cargadas SIN buscar. Si no las usas estas pagando el coste de FTS innecesariamente:
+
+| Senal | Donde | Que hacer |
+|---|---|---|
+| Linea `CAPABILITIES (cache 1h): TOP: ... FRESH (7d): ... PIPELINES: ...` en cada UserPromptSubmit | hook `hook_capabilities_inject.sh` | Antes de buscar con `mcp__registry__fn_search`, mira si la funcion que necesitas esta en TOP/FRESH/PIPELINES. Si si, ve directo a `fn show <id>` (1 read) o `./fn run <id>` (0 reads). |
+| `<system-reminder>FUZZY-MATCH (issue 0087): your Bash command may already be a function. USE: ./fn run <id> -> <signature>` aparecido mid-flight | hook `hook_fn_match.sh` (PreToolUse, Bash matcher) | El hook detecto que tu Bash inline coincide con una funcion del registry. **NO ignores el reminder** — abandona el inline, llama a `./fn run <id>` o `mcp__registry__fn_run id="<id>"`. Si crees que la sugerencia es falso positivo, justifica brevemente antes de seguir inline (queda en violations). |
+| Hint AUSENTE para una query corta (`rsi sma` < 3 tokens) | threshold `raw_score >= 4.0` no alcanzado | NO interpretar la ausencia de hint como "no existe funcion". Usa `mcp__registry__fn_search` con query mas rica (3+ tokens del dominio). |
+| Falso positivo conocido: `agent` token | `robots.txt user-agent` matchea `agent_scaffold` | Ignora el reminder y sigue. Cost = 1 reminder ignorable. |
+
+## Como combinar la 3 senales para minimizar pasos
+
+1. **User prompt llega** -> lees `CAPABILITIES` line. Si la tarea encaja claramente con TOP/FRESH -> usa directo.
+2. **Vas a escribir Bash inline** -> el hook PreToolUse lo intercepta. Si dispara FUZZY-MATCH -> usa `./fn run <id>`.
+3. **No hay match y necesitas codigo** -> `mcp__registry__fn_search` con 3+ tokens. Si sigue sin hit -> delega a `fn-constructor` (no escribas inline). Patron repetido detectado por `call_monitor sequences` se promovera a pipeline en proximas iteraciones.
+
+## Las 4 metricas norte (donde vigilarlas)
+
+- `Reg %` (Monitor KPI) — % calls con function_id no vacio. Sube cuando el registry se usa.
+- `MCP` (Monitor KPI) — count calls con tools registry-aware (mcp*/heredoc*/fn_cli_run). Adopcion de patrones canonicos.
+- `Errors` / `Violations` (Monitor KPI) — bajan cuando el bucle cierra.
+- `Failed Functions` (Monitor sub-tab) — registry-functions que fallaron: diagnostico de bugs prioritarios.
+
 Issue 0085 fase autocompleta. Reemplaza el flujo manual de "veo un patron, decido si extraer, escribo proposal, espero humano, fn-mejorador genera, fn-orquestador opera". Con `/fn_claude` Claude hace todo eso solo, **autonomamente para si mismo**.
 
 ---

.claude/rules/INDEX.md

@@ -33,3 +33,4 @@ Reglas operativas del proyecto. Cada archivo es una regla independiente.
 | 27 | [registry_calls.md](registry_calls.md) | Patrones canonicos para invocar funciones del registry (MCP inspect / MCP run / heredoc compose), antipatrones, excepciones, telemetria. Issue 0085 |
 | 28 | [delegation.md](delegation.md) | Si vas a escribir logica reutilizable inline -> spawn fn-constructor inmediato + tag de grupo + usar en mismo turno. Issue 0086 |
 | 29 | [capability_groups.md](capability_groups.md) | Tags planos + paginas madre `docs/capabilities/<grupo>.md` para desbloquear clusters de funciones en un read. Issue 0086 |
+| 30 | [function_growth_and_self_docs.md](function_growth_and_self_docs.md) | Contrato self-doc de cada `.md` (Ejemplo + Cuando usarla + Gotchas + Growth log) + crecimiento del registry por **promocion de composiciones** a pipelines, NO por inflado de funciones. Issue 0087 |

.claude/rules/function_growth_and_self_docs.md

@@ -0,0 +1,115 @@
+## Function growth + self-documenting capability
+
+Dos doctrinas hermanas. Una define **como deben ser** las funciones (auto-descubribles y lanzables sin segunda lectura). La otra define **como crece** el registry (no inflando funciones — promoviendo composiciones a pipelines).
+
+Issue 0087.
+
+---
+
+### Parte A — `.md` autosuficiente (contrato OBLIGATORIO)
+
+Cuando Claude (o un humano) encuentra una funcion via FTS / fuzzy match / capability page / TOP block, el `.md` debe bastar para **lanzarla sin abrir el codigo**. Esto es lo que hace que descubrir = lanzar y elimina el coste del second lookup.
+
+**Secciones obligatorias** en cada `.md` del registry (functions + pipelines + types con uso practico):
+
+| Seccion | Contenido | Tamaño |
+|---|---|---|
+| Frontmatter | `name`, `signature`, `params` (con `desc` por param), `output`, `tags`, `uses_functions`, etc. Lo de hoy. | — |
+| `## Ejemplo` | Bloque de codigo lanzable con args **concretos**. Copiar+pegar produce ejecucion real. NO placeholders abstractos. | 3-10 lineas |
+| `## Cuando usarla` | 1-2 frases con triggers: "cuando hagas X / antes de Y / si necesitas Z". Verbos imperativos. Ayuda al fuzzy match y a Claude a saber sin leer el codigo. | 1-3 lineas |
+| `## Gotchas` | Problemas conocidos / no-go cases. Obligatoria para funciones impuras o con efectos (Windows-side, red, FS write, GPU). Omisible para funciones puras triviales. | 0-5 puntos |
+| `## Capability growth log` | Solo SI la funcion ha crecido. Una linea por version: `v1.1.0 (YYYY-MM-DD) — anade --build flag para skip build`. No se rellena en v1.0.0. | crece con el tiempo |
+
+**Anti-patrones del .md:**
+
+- Ejemplo con `<arg1>`, `<arg2>` placeholders abstractos — NO. Ejemplos con valores reales (`registry_dashboard`, `/home/lucas/...`).
+- "Cuando usarla" vacio o "ver descripcion arriba" — NO. Frase nueva con trigger explicito.
+- `notes` lleno + `## Gotchas` vacio cuando la funcion tiene efectos — mover de `notes` a `## Gotchas`.
+- Capability growth log inventado (sin que la funcion haya cambiado) — NO. Solo se rellena cuando hay version bump real.
+
+**Verificacion** (TBD: convertir a check de `fn doctor`): cada .md de `functions/`/`pipelines/` debe tener `## Ejemplo` y `## Cuando usarla`. `## Gotchas` obligatoria solo si `purity: impure`. `## Capability growth log` libre.
+
+---
+
+### Parte B — Crecimiento por composicion (no por inflado)
+
+**Principio:** una funcion que hace bien UNA cosa NO necesita crecer. Anadir params "por si acaso" la hace peor (Inner Platform Effect). Lo que crece es el **registry**: pipelines nuevos que componen funciones existentes.
+
+#### Ejemplo del principio
+
+- **Hoy:** Claude para hacer una transferencia bancaria llama `bank_login` -> `bank_list_accounts` -> `bank_make_transfer`. 3 calls, 3 decisiones, 3 puntos de fallo.
+- **Manana:** pipeline `bank_transfer_oneshot(account, amount, target)` que compone las 3 internamente. 1 call, 1 decision.
+
+Misma capacidad, 3x menos pasos. **Esto es lo que multiplica la velocidad de Claude**, no anadir flags a `bank_login`.
+
+#### Como se promueve una composicion
+
+Senal detectable en `call_monitor.operations.db`: secuencia A→B(→C) con
+
+- **Mismo session_id**.
+- **Intervalo entre calls < N segundos** (default 30s).
+- **Occurrences > K** (default 5) en ventana de **D dias** (default 30).
+- **Success rate > S** (default 0.9 — falla < 10%).
+- **No existe ya un pipeline** que la cubra (validar con FTS sobre `uses_functions`).
+
+Cuando se cumple → **proposal `new_pipeline`** con evidencia (sequence_ids, session_ids, occurrence count). Humano (o `fn-orquestador` autonomo) decide promover.
+
+#### Implementacion (issue 0087 tanda A)
+
+- `call_monitor sequences --detect` subcomando: escanea `calls` table, agrupa por session+window, computa secuencias, upserta en tabla `function_sequences`.
+- Cron diario que ejecuta el detector + genera proposals automaticas.
+- Visible en Monitor tab del `registry_dashboard`: sub-tab "Promotion candidates".
+
+#### Cuando SI inflar una funcion
+
+Casos legitimos para anadir feature a una funcion existente:
+
+1. **Generalizar firma** sin romper consumidores (anadir param opcional con default sensato).
+2. **Mejor manejo de error** (mensajes mas claros, retry sensible).
+3. **Default mas inteligente** (autodetectar lo que antes era arg obligatorio).
+4. **Eliminar gotcha conocido** (fix de bug que estaba en `## Gotchas`).
+
+NO infles para casos hipoteticos. NO anadas params "por flexibilidad". Si dudas, separa la responsabilidad en una funcion nueva o un pipeline.
+
+#### Capability growth log — cuando se rellena
+
+- Se rellena **solo cuando la funcion crece** (alguno de los 4 casos arriba).
+- Cada bump de `version` -> 1 linea en `## Capability growth log` con fecha y resumen 1-frase.
+- Una funcion estable de hace 6 meses puede seguir en v1.0.0 sin log: indica madurez, no abandono.
+- Telemetria (call_monitor) decide si una funcion estable es huerfana (`calls_90d=0`) o usada-y-buena (`calls_30d>10, error_rate<0.05`). Las primeras se deprecan; las segundas se respetan.
+
+---
+
+### Parte C — Output de discovery
+
+Cuando un mecanismo de discovery (fuzzy match / FRESH hook / TOP block / capability page) surfacea una funcion, el payload **minimo** es:
+
+```
+<id>  →  <signature>  →  <ejemplo de 1 linea>
+```
+
+Ejemplo concreto:
+```
+redeploy_cpp_app_windows_bash_pipelines
+  ./fn run redeploy_cpp_app_windows registry_dashboard /path/to/app [--build]
+  use: tras compilar cpp/build/windows, antes de smoke test manual
+```
+
+Si Claude necesita mas (gotchas, params completos, codigo), un `mcp__registry__fn_show <id>` adicional. Pero el primer hit ya basta para el 80% de casos.
+
+---
+
+### Parte D — Relacion con otras reglas
+
+- [[registry_first]] dice CUANDO buscar/usar/delegar. Esta regla dice **COMO** debe ser la funcion para que esa busqueda valga.
+- [[ids_naming]] hace ID predictible. Esta regla hace metadata predictible.
+- [[delegation]] dice cuando spawnar fn-constructor. Esta regla es lo que fn-constructor debe producir.
+- [[capability_groups]] agrupa funciones afines. Las paginas madre de cada grupo deben respetar el mismo contrato self-doc (mejor con su propio ejemplo end-to-end por grupo).
+
+### Resumen TL;DR
+
+1. Cada `.md` autosuficiente: Ejemplo + Cuando usarla + Gotchas (si impura) + Growth log (si crecio).
+2. Las funciones que hacen bien una cosa NO necesitan crecer.
+3. El registry crece **promoviendo composiciones repetidas a pipelines**, no inflando funciones.
+4. Telemetria de `call_monitor` detecta secuencias candidatas y abre proposals automaticas.
+5. Discovery devuelve siempre: `id + signature + 1-line example`. Resto on-demand.

.claude/rules/registry_calls.md

@@ -33,6 +33,21 @@ Casos donde el MCP no aplica y `sqlite3 registry.db` es legitimo:
 
 El hook `PreToolUse` (`.claude/scripts/hook_registry_mcp.sh`) ya deja pasar estas excepciones y solo avisa cuando ve `sqlite3 registry.db "SELECT ..."` plano.
 
+### Excepcion: hooks e infraestructura de telemetria (issue 0087)
+
+Los **hooks** (`PreToolUse`, `PostToolUse`, `UserPromptSubmit`, etc.) y los **binarios de infraestructura** que sirven al agente (`fn_match`, `fn doctor`, `call_monitor`) **pueden leer `registry.db` directo** via `sqlite3` o `database/sql` con conexion read-only. NO estan sujetos a la regla MCP-first porque:
+
+- No son acciones del agente — son inspeccion automatizada del entorno.
+- El MCP requiere tool invocation por Claude; un hook no puede invocar tools.
+- Latencia objetivo (50-200ms) incompatible con round-trip MCP.
+
+**Restricciones:**
+- SOLO lectura. Conexion debe abrirse con `?mode=ro` o `?_query_only=1`.
+- NUNCA escritura a `registry.db` desde hooks.
+- Si un hook necesita escribir (cache, telemetria propia), usa su propia DB (`operations.db` del app de hooks, o `~/.fn_hooks/cache.db`).
+
+Esta excepcion es **explicita y acotada** — no aplica al agente, que sigue regido por la regla MCP-first.
+
 ### Verificacion previa — `fn doctor`
 
 Antes de empezar trabajo no trivial sobre el registry, ejecutar `fn doctor` para confirmar que el ecosistema esta sano:

.claude/scripts/hook_call_monitor.sh

@@ -59,15 +59,24 @@ ARGS_HASH=$(printf '%s' "$INPUT" | jq -c '.tool_input // {}' | sha256sum | cut -
 sql_escape() { printf '%s' "$1" | sed "s/'/''/g"; }
 
 insert_call() {
-    local fn_id="$1" tool_used="$2" duration_ms="${3:-0}"
-    local fn_esc tu_esc ec_esc es_esc sid_esc ah_esc
+    local fn_id="$1" tool_used="$2" duration_ms="${3:-0}" snippet="${4:-}"
+    local fn_esc tu_esc ec_esc es_esc sid_esc ah_esc snip_esc
+    # Politica issue 0087: command_snippet solo se rellena cuando function_id
+    # esta vacio. Si la call golpea una funcion del registry, su ID y
+    # tool_used bastan; no duplicamos el comando.
+    if [ -n "$fn_id" ]; then snippet=""; fi
+    # Redact common secrets antes de persistir
+    snippet=$(printf '%s' "$snippet" \
+        | sed -E 's/(password|token|secret|api[_-]?key|bearer)([[:space:]]*[=:][[:space:]]*)[^[:space:]]+/\1\2<REDACTED>/Ig' \
+        | head -c 200)
     fn_esc=$(sql_escape "$fn_id")
     tu_esc=$(sql_escape "$tool_used")
     ec_esc=$(sql_escape "$ERROR_CLASS")
     es_esc=$(sql_escape "$ERROR_SNIPPET")
     sid_esc=$(sql_escape "$SESSION_ID")
     ah_esc=$(sql_escape "$ARGS_HASH")
-    sqlite3 "$DB" "INSERT INTO calls (session_id, function_id, tool_used, args_hash, duration_ms, success, error_class, error_snippet, ts) VALUES ('$sid_esc','$fn_esc','$tu_esc','$ah_esc',$duration_ms,$SUCCESS,'$ec_esc','$es_esc',$TS);" 2>/dev/null || true
+    snip_esc=$(sql_escape "$snippet")
+    sqlite3 "$DB" "INSERT INTO calls (session_id, function_id, tool_used, args_hash, duration_ms, success, error_class, error_snippet, command_snippet, ts) VALUES ('$sid_esc','$fn_esc','$tu_esc','$ah_esc',$duration_ms,$SUCCESS,'$ec_esc','$es_esc','$snip_esc',$TS);" 2>/dev/null || true
 }
 
 insert_code_write() {
@@ -204,7 +213,7 @@ case "$TOOL_NAME" in
             TOOL_USED="sqlite_direct"
         fi
 
-        insert_call "$FN_ID" "$TOOL_USED"
+        insert_call "$FN_ID" "$TOOL_USED" 0 "$CMD_HEAD"
 
         # ---- Violation rules ----
         # 1. sqlite3 directo SELECT sobre registry.db (excepto schema/pragma/count/join)

.claude/scripts/hook_capabilities_inject.sh

@@ -0,0 +1,121 @@
+#!/usr/bin/env bash
+# UserPromptSubmit hook: inyecta capacidades calientes (TOP/FRESH/PIPELINES)
+# del registry como additionalContext en cada turno del usuario.
+#
+# Cache: ~/.cache/fn_registry/capabilities.txt (TTL 1h).
+# Fuente: `./fn doctor capabilities --emit-claude-md` desde la raiz del repo.
+#
+# NUNCA bloquea: si algo falla, emite contexto vacio y sale 0.
+
+set -uo pipefail
+
+CACHE_DIR="${HOME}/.cache/fn_registry"
+CACHE_FILE="${CACHE_DIR}/capabilities.txt"
+TTL_SECONDS=3600
+
+# Resolve registry root (walks up from cwd, fallback CLAUDE_PROJECT_DIR)
+resolve_root() {
+    local d="${PWD}"
+    while [ "$d" != "/" ]; do
+        if [ -f "$d/registry.db" ] && [ -x "$d/fn" ]; then
+            printf '%s' "$d"
+            return 0
+        fi
+        d=$(dirname "$d")
+    done
+    if [ -n "${CLAUDE_PROJECT_DIR:-}" ] && [ -f "${CLAUDE_PROJECT_DIR}/registry.db" ]; then
+        printf '%s' "${CLAUDE_PROJECT_DIR}"
+        return 0
+    fi
+    return 1
+}
+
+# Consume stdin (UserPromptSubmit payload) — we don't need it but keep stdin clean
+cat >/dev/null 2>&1 || true
+
+ROOT=$(resolve_root) || exit 0
+mkdir -p "$CACHE_DIR" 2>/dev/null || exit 0
+
+# Cache freshness check
+need_refresh=1
+if [ -f "$CACHE_FILE" ]; then
+    now=$(date +%s)
+    mtime=$(stat -c %Y "$CACHE_FILE" 2>/dev/null || stat -f %m "$CACHE_FILE" 2>/dev/null || echo 0)
+    age=$((now - mtime))
+    if [ "$age" -lt "$TTL_SECONDS" ]; then
+        need_refresh=0
+    fi
+fi
+
+if [ "$need_refresh" -eq 1 ]; then
+    # Regenerate: call fn doctor capabilities --emit-claude-md and process
+    raw=$("$ROOT/fn" doctor capabilities --emit-claude-md 2>/dev/null || true)
+    if [ -z "$raw" ]; then
+        exit 0
+    fi
+
+    # Extract top 5 from each section using awk.
+    # Sections detected by "## ... Top" / "## ... Fresh" / "## ... Pipelines".
+    line=$(printf '%s\n' "$raw" | awk '
+        BEGIN { sec=""; n_top=0; n_fresh=0; n_pipe=0; }
+        /^## .*Top 20/   { sec="TOP";    next }
+        /^## .*Fresh/    { sec="FRESH";  next }
+        /^## .*Pipelines/ { sec="PIPE"; next }
+        /^## /           { sec="";       next }
+        /^- `/ {
+            # extract first backticked token
+            s = $0
+            sub(/^- `/, "", s)
+            i = index(s, "`")
+            if (i == 0) next
+            id = substr(s, 1, i-1)
+            if (sec == "TOP"   && n_top   < 5) { tops[n_top++]     = id }
+            if (sec == "FRESH" && n_fresh < 5) { fresh[n_fresh++]  = id }
+            if (sec == "PIPE"  && n_pipe  < 5) { pipes[n_pipe++]   = id }
+        }
+        END {
+            out = "CAPABILITIES (cache 1h):"
+            if (n_top > 0) {
+                line = "  TOP: " tops[0]
+                for (i=1; i<n_top; i++) line = line ", " tops[i]
+                out = out "\n" line
+            }
+            if (n_fresh > 0) {
+                line = "  FRESH (7d): " fresh[0]
+                for (i=1; i<n_fresh; i++) line = line ", " fresh[i]
+                out = out "\n" line
+            }
+            if (n_pipe > 0) {
+                line = "  PIPELINES: " pipes[0]
+                for (i=1; i<n_pipe; i++) line = line ", " pipes[i]
+                out = out "\n" line
+            }
+            print out
+        }
+    ')
+
+    if [ -z "$line" ]; then
+        exit 0
+    fi
+    printf '%s\n' "$line" >"$CACHE_FILE" 2>/dev/null || exit 0
+fi
+
+# Emit cached content as additionalContext
+if [ ! -s "$CACHE_FILE" ]; then
+    exit 0
+fi
+
+ctx=$(cat "$CACHE_FILE")
+if command -v jq >/dev/null 2>&1; then
+    jq -n --arg ctx "$ctx" '{
+      hookSpecificOutput: {
+        hookEventName: "UserPromptSubmit",
+        additionalContext: $ctx
+      }
+    }'
+else
+    # Fallback: print raw text (Claude Code prints stdout as context too)
+    printf '%s\n' "$ctx"
+fi
+
+exit 0

.claude/scripts/hook_fn_match.sh

@@ -0,0 +1,133 @@
+#!/usr/bin/env bash
+# PreToolUse hook: sugiere funciones del registry cuando un comando Bash
+# inline probablemente reinventa una funcion existente (issue 0087).
+#
+# Llama a `./fn match "<cmd>"` con timeout 200ms. Si encaja con alta
+# confianza, imprime un <system-reminder> a stderr para que Claude Code
+# lo lea como recordatorio. NUNCA bloquea la tool — exit 0 siempre.
+
+set -euo pipefail
+
+# ---- Always exit 0, no matter what ----
+trap 'exit 0' ERR
+
+# ---- Resolve registry root (walks up from cwd) ----
+resolve_root() {
+    local d="${PWD}"
+    while [ "$d" != "/" ]; do
+        if [ -f "$d/registry.db" ]; then
+            printf '%s' "$d"
+            return 0
+        fi
+        d=$(dirname "$d")
+    done
+    return 1
+}
+
+ROOT=$(resolve_root) || exit 0
+FN_BIN="$ROOT/fn"
+[ -x "$FN_BIN" ] || exit 0
+
+# ---- Read stdin JSON ----
+command -v jq >/dev/null 2>&1 || exit 0
+INPUT=$(cat)
+[ -z "$INPUT" ] && exit 0
+
+TOOL_NAME=$(printf '%s' "$INPUT" | jq -r '.tool_name // ""' 2>/dev/null || echo "")
+[ "$TOOL_NAME" = "Bash" ] || exit 0
+
+CMD=$(printf '%s' "$INPUT" | jq -r '.tool_input.command // ""' 2>/dev/null || echo "")
+[ -z "$CMD" ] && exit 0
+
+# Single-line for matching against denylist patterns
+CMD_FLAT=$(printf '%s' "$CMD" | tr '\n' ' ')
+
+# ---- Denylist (skip antes de llamar fn match para ahorrar el invoke) ----
+
+# Comandos demasiado cortos -> trivial
+CMD_LEN=${#CMD_FLAT}
+[ "$CMD_LEN" -lt 20 ] && exit 0
+
+# Trivial single-utility commands
+case "$CMD_FLAT" in
+    "ls"|"ls "*|"cd"|"cd "*|"pwd"|"pwd "*|"cat"|"cat "*|"echo"|"echo "*)
+        exit 0 ;;
+    "grep"|"grep "*|"head"|"head "*|"tail"|"tail "*|"wc"|"wc "*)
+        exit 0 ;;
+    "mkdir"|"mkdir "*|"rm"|"rm "*|"mv"|"mv "*|"cp"|"cp "*)
+        exit 0 ;;
+    "git"|"git "*)
+        exit 0 ;;
+    "go"|"go "*)
+        # go build / go test corrientes — el agente ya los maneja
+        exit 0 ;;
+esac
+
+# Comandos que ya usan el registry: ./fn ..., fn run ..., mcp__registry__*
+if printf '%s' "$CMD_FLAT" | grep -qE '(^|[[:space:]])\./fn([[:space:]]|$)'; then
+    exit 0
+fi
+if printf '%s' "$CMD_FLAT" | grep -qE '(^|[[:space:]])fn[[:space:]]+(run|search|show|code|uses|doctor|index|match|list|add|proposal|sync|ops|check)'; then
+    exit 0
+fi
+
+# Pure-cd (movement only, no logic)
+if printf '%s' "$CMD_FLAT" | grep -qE '^[[:space:]]*cd[[:space:]]+[^&|;]+$'; then
+    exit 0
+fi
+
+# ---- Llamar fn match con timeout 200ms ----
+command -v timeout >/dev/null 2>&1 || exit 0
+
+# Truncar el comando a algo razonable para fn match (evitar args huge)
+CMD_TRUNC=$(printf '%s' "$CMD_FLAT" | head -c 500)
+
+MATCH_JSON=$(timeout 0.2 "$FN_BIN" match "$CMD_TRUNC" --format json --top 3 2>/dev/null) || exit 0
+[ -z "$MATCH_JSON" ] && exit 0
+
+# ---- Parsear JSON ----
+HIGH_CONF=$(printf '%s' "$MATCH_JSON" | jq -r '.high_confidence // false' 2>/dev/null || echo "false")
+TOP_ID=$(printf '%s' "$MATCH_JSON" | jq -r '.top[0].id // ""' 2>/dev/null || echo "")
+TOP_SCORE=$(printf '%s' "$MATCH_JSON" | jq -r '.top[0].score // 0' 2>/dev/null || echo "0")
+TOP_SIG=$(printf '%s' "$MATCH_JSON" | jq -r '.top[0].signature // ""' 2>/dev/null || echo "")
+TOP_SNIP=$(printf '%s' "$MATCH_JSON" | jq -r '.top[0].snippet // ""' 2>/dev/null || echo "")
+
+[ -z "$TOP_ID" ] && exit 0
+
+# Trigger condition: (high_confidence==true OR score>=0.85) AND score>=0.6
+# - high_confidence requires top1/top2 gap > 1.5 (set por fn match)
+# - score>=0.85 cubre matches muy fuertes donde el gap es modesto
+SCORE_HI=$(awk -v s="$TOP_SCORE" 'BEGIN{ print (s+0 >= 0.85) ? "1" : "0" }')
+SCORE_MIN=$(awk -v s="$TOP_SCORE" 'BEGIN{ print (s+0 >= 0.6) ? "1" : "0" }')
+
+[ "$SCORE_MIN" = "1" ] || exit 0
+if [ "$HIGH_CONF" != "true" ] && [ "$SCORE_HI" != "1" ]; then
+    exit 0
+fi
+
+# Truncar snippet a 100 chars y limpiar saltos de linea
+SNIP_SHORT=$(printf '%s' "$TOP_SNIP" | tr '\n' ' ' | head -c 100)
+
+# Formatear score con 2 decimales
+SCORE_FMT=$(awk -v s="$TOP_SCORE" 'BEGIN{ printf "%.2f", s+0 }')
+
+# ---- Emitir <system-reminder> a stderr ----
+cat >&2 <<EOF
+<system-reminder>FUZZY-MATCH (issue 0087): your Bash command may already be a function.
+USE: ./fn run $TOP_ID  ->  $TOP_SIG
+SNIPPET: $SNIP_SHORT
+Confidence: $SCORE_FMT. If you proceed inline, the violation will be logged.
+</system-reminder>
+EOF
+
+exit 0
+
+# Test manual:
+# echo '{"tool_name":"Bash","tool_input":{"command":"taskkill.exe /IM registry_dashboard.exe /F"},"session_id":"test"}' \
+#   | bash .claude/scripts/hook_fn_match.sh
+#
+# Casos silenciosos:
+# echo '{"tool_name":"Bash","tool_input":{"command":"ls -la"},"session_id":"test"}' \
+#   | bash .claude/scripts/hook_fn_match.sh
+# echo '{"tool_name":"Bash","tool_input":{"command":"./fn run filter_slice_go_core 1 2 3"},"session_id":"test"}' \
+#   | bash .claude/scripts/hook_fn_match.sh