feat(infra): auto-commit con 29 cambios

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

bash/functions/infra/build_cpp_windows.md

@@ -7,7 +7,7 @@ version: "1.0.0"
 purity: impure
 signature: "build_cpp_windows(target?: string) -> void"
 description: "Cross-compila las funciones y apps C++ del registry para Windows usando mingw-w64"
-tags: [cpp, build, cmake, windows, cross-compile, mingw, imgui]
+tags: [cpp, build, cmake, windows, cross-compile, mingw, imgui, cpp-windows]
 uses_functions: []
 uses_types: []
 returns: []

bash/functions/infra/deploy_cpp_exe_to_windows.md

@@ -7,7 +7,7 @@ version: "1.0.0"
 purity: impure
 signature: "deploy_cpp_exe_to_windows(app_name: string, app_dir: string) -> void"
 description: "Copia el .exe de Windows (compilado por build_cpp_windows) y sus assets al escritorio de Windows /mnt/c/Users/lucas/Desktop/apps/<APP>/. Mata el proceso si esta corriendo (taskkill.exe pre-autorizado), copia DLLs, sincroniza assets/ y enrichers/ con rsync, maneja runtime Python embebido si python_runtime: true en app.md, y copia extras gx-cli. Preserva siempre local_files/ (estado del usuario)."
-tags: [cpp, deploy, windows, exe, dll, assets, rsync]
+tags: [cpp, deploy, windows, exe, dll, assets, rsync, cpp-windows]
 uses_functions: []
 uses_types: []
 returns: []

bash/functions/infra/e2e_run_cpp_windows.md

@@ -3,7 +3,7 @@ name: e2e_run_cpp_windows
 lang: bash
 domain: infra
 description: "Cross-compila una app C++ del registry para Windows con mingw-w64, deploy al Desktop\\apps de Windows (matando instancia previa con taskkill.exe), lanza el .exe nativamente desde WSL y devuelve stdout + exit code. Pensado para tests headless tipo altsnap_jitter_test."
-tags: [windows, e2e, cross-compile, test, mingw, pendiente-usar]
+tags: [windows, e2e, cross-compile, test, mingw, pendiente-usar, cpp-windows]
 purity: impure
 kind: function
 signature: "e2e_run_cpp_windows(target string, --no-build, --no-deploy) int"

bash/functions/infra/is_cpp_app_running_windows.md

@@ -0,0 +1,70 @@
+---
+name: is_cpp_app_running_windows
+kind: function
+lang: bash
+domain: infra
+version: "1.0.0"
+purity: impure
+signature: "is_cpp_app_running_windows(app_name: string) -> void"
+description: "Comprueba si un ejecutable Windows esta corriendo via tasklist.exe desde WSL2. Exit 0 si el proceso existe, exit 1 si no."
+tags: [cpp, windows, monitoring, wsl, tasklist, process, cpp-windows]
+uses_functions: []
+uses_types: []
+returns: []
+returns_optional: false
+error_type: "error_go_core"
+imports: []
+tested: false
+tests: []
+test_file_path: ""
+file_path: "bash/functions/infra/is_cpp_app_running_windows.sh"
+params:
+  - name: app_name
+    desc: "Nombre del binario sin extension .exe (ej. registry_dashboard). Se le añade .exe internamente para el filtro de tasklist."
+output: "Exit 0 con stdout 'RUNNING: PID=<pid> MEM=<mem>' si el proceso existe. Exit 1 con stdout 'NOT_RUNNING: <app_name>' si no. Exit 1 con stderr si tasklist.exe no esta disponible."
+---
+
+## Ejemplo
+
+```bash
+if is_cpp_app_running_windows "registry_dashboard"; then
+    echo "Ya esta corriendo"
+else
+    launch_cpp_app_windows "registry_dashboard"
+fi
+```
+
+Composicion tipica en pipelines de redeploy:
+
+```bash
+# Matar antes de copiar si esta vivo
+if is_cpp_app_running_windows "$app"; then
+    taskkill.exe /IM "${app}.exe" /F
+fi
+deploy_cpp_exe_to_windows "$app" "$app_dir"
+launch_cpp_app_windows "$app"
+```
+
+## Comportamiento
+
+El exit code es la API principal; stdout es informacion adjunta parseable por el caller:
+
+| Situacion | Exit | Stdout |
+|---|---|---|
+| Proceso encontrado | 0 | `RUNNING: PID=<n> MEM=<n>K` |
+| Proceso no encontrado | 1 | `NOT_RUNNING: <app_name>` |
+| `tasklist.exe` no disponible | 1 | (stderr) `ERROR: tasklist.exe no encontrado` |
+| `app_name` vacio | 1 | (stderr) `ERROR: uso: ...` |
+
+El formato `RUNNING: PID=N MEM=...K` esta pensado para ser parseado por `cut -d= -f2` si el caller necesita el PID.
+
+## Prerequisitos
+
+- WSL2 con acceso a herramientas Windows (`/mnt/c/Windows/System32/tasklist.exe`).
+- El proceso debe haber sido lanzado via `launch_cpp_app_windows` o cualquier otro mecanismo que cree un proceso Windows con el nombre del `.exe`.
+
+## Notas
+
+Util para componer con `launch_cpp_app_windows` y `deploy_cpp_exe_to_windows` en pipelines de redeploy desde WSL2. `deploy_cpp_exe_to_windows` ya incluye un `taskkill.exe` interno antes de copiar, pero esta funcion permite tomar la decision de matar/no matar de forma explicita en el caller.
+
+Tasklist con `/NH /FO CSV` no emite header, por lo que la primera linea de salida con el nombre de imagen es directamente el primer proceso coincidente. Si hay multiples instancias del mismo `.exe`, se informa solo del primero (PID mas bajo en el listado del sistema).

bash/functions/infra/is_cpp_app_running_windows.sh

@@ -0,0 +1,45 @@
+#!/usr/bin/env bash
+# is_cpp_app_running_windows — Comprueba si un .exe de Windows esta corriendo
+# via tasklist.exe desde WSL2. Exit 0 si vivo, exit 1 si no.
+
+is_cpp_app_running_windows() {
+    local app_name="${1:-}"
+
+    if [ -z "$app_name" ]; then
+        echo "ERROR: uso: is_cpp_app_running_windows <app_name>" >&2
+        return 1
+    fi
+
+    # Verificar que tasklist.exe esta disponible
+    if ! command -v tasklist.exe >/dev/null 2>&1; then
+        echo "ERROR: tasklist.exe no encontrado (requiere WSL2 con acceso a Windows tools)" >&2
+        return 1
+    fi
+
+    # /NH: sin header, /FO CSV: salida CSV, /FI: filtro por imagen
+    local output
+    output=$(tasklist.exe /FI "IMAGENAME eq ${app_name}.exe" /NH /FO CSV 2>/dev/null)
+
+    # tasklist.exe devuelve "INFO: No tasks..." cuando no hay coincidencia.
+    # Con CSV+NH, cada proceso encontrado produce: "imagen.exe","pid","tipo","sesion","mem"
+    if echo "$output" | grep -qi "\"${app_name}.exe\""; then
+        # Extraer PID y memoria de la primera linea que coincida
+        local line
+        line=$(echo "$output" | grep -i "\"${app_name}.exe\"" | head -n1)
+
+        # Campos CSV: "imagen","PID","tipo","sesion","MEM K"
+        local pid mem
+        pid=$(echo "$line" | cut -d',' -f2 | tr -d '"')
+        mem=$(echo "$line" | cut -d',' -f5 | tr -d '"' | tr -d ' ')
+
+        echo "RUNNING: PID=${pid} MEM=${mem}"
+        return 0
+    else
+        echo "NOT_RUNNING: ${app_name}"
+        return 1
+    fi
+}
+
+if [ "${BASH_SOURCE[0]}" = "$0" ]; then
+    is_cpp_app_running_windows "$@"
+fi

bash/functions/infra/launch_cpp_app_windows.md

@@ -0,0 +1,70 @@
+---
+name: launch_cpp_app_windows
+kind: function
+lang: bash
+domain: infra
+version: "1.0.0"
+purity: impure
+signature: "launch_cpp_app_windows(app_name: string, [desktop_dir: string]) -> void"
+description: "Lanza un binario .exe en Windows desde WSL2. Asume que deploy_cpp_exe_to_windows ya copió el exe a Desktop/apps/<app_name>/. Usa cmd.exe /c start para desacoplar el proceso y retornar inmediatamente."
+tags: [cpp, windows, launch, wsl, exe, cpp-windows]
+uses_functions: []
+uses_types: []
+returns: []
+returns_optional: false
+error_type: "error_go_core"
+imports: []
+tested: false
+tests: []
+test_file_path: ""
+file_path: "bash/functions/infra/launch_cpp_app_windows.sh"
+params:
+  - name: app_name
+    desc: "Nombre de la app (ej: registry_dashboard). Localiza Desktop/apps/<app_name>/<app_name>.exe."
+  - name: desktop_dir
+    desc: "Override opcional del directorio escritorio Windows. Default: /mnt/c/Users/lucas/Desktop."
+output: "Imprime 'OK: <app_name> launched at <ts>' en stdout si el exe existe y el comando se lanza. Errores fatales a stderr con exit 1."
+---
+
+## Ejemplo
+
+```bash
+source bash/functions/infra/launch_cpp_app_windows.sh
+
+# Lanzar con default desktop dir
+launch_cpp_app_windows "registry_dashboard"
+# OK: registry_dashboard launched at 2026-05-14T10:32:01
+
+# Override de desktop_dir (ej. otro usuario)
+launch_cpp_app_windows "chart_demo" "/mnt/c/Users/otrouser/Desktop"
+# OK: chart_demo launched at 2026-05-14T10:32:05
+```
+
+## Comportamiento
+
+`cmd.exe /c start` es la clave: lanza el proceso en Windows y **retorna inmediatamente** sin esperar a que el exe termine. El proceso queda desacoplado del shell WSL2. Esta funcion **no verifica** que el exe arranco correctamente ni que sigue corriendo — esa responsabilidad recae en `is_cpp_app_running_windows` (funcion complementaria).
+
+El `cd /d` previo al `start` es esencial: los apps C++ del registry buscan sus assets, `local_files/` y DLLs relativos al directorio de trabajo. Sin el `cd`, Windows buscaria desde `C:\Windows\System32` y el exe no encontraria nada.
+
+## Prerequisitos
+
+- **WSL2**: la funcion usa `wslpath -w` y `cmd.exe`, ambos solo disponibles en WSL2.
+- **`/mnt/c/` montado**: el exe debe ser accesible via la ruta `/mnt/c/...`.
+- **Exe ya copiado**: `deploy_cpp_exe_to_windows` debe haberse ejecutado antes. Esta funcion no compila ni copia nada.
+
+## Notes
+
+Mitad complementaria de `deploy_cpp_exe_to_windows_bash_infra`. El flujo completo para actualizar y relanzar una app es:
+
+```bash
+# 1. Compilar para Windows
+build_cpp_windows "registry_dashboard"
+
+# 2. Copiar al escritorio (mata proceso si corre, copia DLLs+assets)
+deploy_cpp_exe_to_windows "registry_dashboard" "/home/lucas/fn_registry/apps/registry_dashboard"
+
+# 3. Lanzar
+launch_cpp_app_windows "registry_dashboard"
+```
+
+No se incluyen tests automatizados porque requieren entorno WSL2 con Windows activo y no son automatizables en CI.

bash/functions/infra/launch_cpp_app_windows.sh

@@ -0,0 +1,42 @@
+#!/usr/bin/env bash
+# launch_cpp_app_windows — Lanza un .exe en Windows desde WSL2 via cmd.exe /c start.
+# Asume que el exe ya fue copiado por deploy_cpp_exe_to_windows al escritorio.
+
+launch_cpp_app_windows() {
+    local app="${1:-}"
+    local desktop_dir="${2:-/mnt/c/Users/lucas/Desktop}"
+
+    if [ -z "$app" ]; then
+        echo "ERROR: uso: launch_cpp_app_windows <app_name> [desktop_dir]" >&2
+        return 1
+    fi
+
+    local exe_path="$desktop_dir/apps/$app/$app.exe"
+
+    if [ ! -f "$exe_path" ]; then
+        echo "ERROR: exe no encontrado: $exe_path" >&2
+        echo "Copia primero con: deploy_cpp_exe_to_windows $app <app_dir>" >&2
+        return 1
+    fi
+
+    # Usamos PowerShell en vez de cmd.exe — los backslashes de paths Windows
+    # no rompen el escaping aqui (cmd.exe `\"` interpreta como escape de
+    # comilla y deja el string sin cerrar; PowerShell single-quote es literal).
+    local win_app_dir win_exe
+    win_app_dir=$(wslpath -w "$desktop_dir/apps/$app")
+    win_exe="$win_app_dir\\$app.exe"
+
+    # Start-Process detacha (equivale a `start` de cmd) y respeta -WorkingDirectory.
+    # Las comillas simples en PowerShell son literales — no procesa \ ni $.
+    powershell.exe -NoProfile -Command \
+        "Start-Process -FilePath '$win_exe' -WorkingDirectory '$win_app_dir'" \
+        >/dev/null 2>&1
+
+    local ts
+    ts=$(date '+%Y-%m-%dT%H:%M:%S')
+    echo "OK: $app launched at $ts"
+}
+
+if [ "${BASH_SOURCE[0]}" = "$0" ]; then
+    launch_cpp_app_windows "$@"
+fi

bash/functions/pipelines/compile_cpp_app.md

@@ -7,7 +7,7 @@ version: "1.0.0"
 purity: impure
 signature: "compile_cpp_app(app_name?: string) -> void"
 description: "Pipeline que resuelve la app C++ desde el nombre o CWD, la cross-compila para Windows con mingw-w64, y despliega el .exe al escritorio de Windows. Composicion de resolve_cpp_app_dir + build_cpp_windows + deploy_cpp_exe_to_windows."
-tags: [cpp, compile, windows, mingw, cross-compile, deploy, pipeline, pendiente-usar]
+tags: [cpp, compile, windows, mingw, cross-compile, deploy, pipeline, pendiente-usar, cpp-windows]
 uses_functions:
   - resolve_cpp_app_dir_bash_infra
   - build_cpp_windows_bash_infra

bash/functions/pipelines/redeploy_cpp_app_windows.md

@@ -0,0 +1,75 @@
+---
+name: redeploy_cpp_app_windows
+kind: pipeline
+lang: bash
+domain: pipelines
+version: "1.0.0"
+purity: impure
+signature: "redeploy_cpp_app_windows(app_name: string, app_dir: string, [--build]) -> void"
+description: "Pipeline orquestador para redeployar una app C++ en Windows desde WSL2 en un solo comando. Reemplaza la secuencia manual taskkill+copy+launch+verify."
+tags: [cpp, windows, redeploy, pipeline, wsl, launcher, cpp-windows]
+uses_functions:
+  - build_cpp_windows_bash_infra
+  - deploy_cpp_exe_to_windows_bash_infra
+  - launch_cpp_app_windows_bash_infra
+  - is_cpp_app_running_windows_bash_infra
+uses_types: []
+returns: []
+returns_optional: false
+error_type: "error_go_core"
+imports: []
+tested: false
+tests: []
+test_file_path: ""
+file_path: "bash/functions/pipelines/redeploy_cpp_app_windows.sh"
+params:
+  - name: app_name
+    desc: "Nombre de la app C++ (ej: chart_demo, registry_dashboard). Se usa para localizar el .exe en cpp/build/windows/apps/<app>/ y el destino Desktop/apps/<app>/."
+  - name: app_dir
+    desc: "Ruta absoluta al directorio fuente de la app (ej: /home/lucas/fn_registry/cpp/apps/chart_demo). Requerido para localizar enrichers/, runtime/ y app.md."
+  - name: "--build"
+    desc: "Flag opcional. Si presente, compila la app para Windows antes del deploy. Por defecto off (asume .exe ya compilado)."
+output: "Imprime 'OK: <app_name> redeployed (build=yes/no, PID=N)' en stdout. Exit 1 en cualquier paso fallido con mensaje de error indicando el paso."
+---
+
+## Ejemplo
+
+```bash
+# Solo redeploy (asume build ya hecho)
+redeploy_cpp_app_windows "registry_dashboard" "/home/lucas/fn_registry/projects/fn_monitoring/apps/registry_dashboard"
+
+# Con build previo
+redeploy_cpp_app_windows "chart_demo" "/home/lucas/fn_registry/cpp/apps/chart_demo" --build
+```
+
+## Comportamiento
+
+1. **Parsear flag `--build`** (default off, opt-in).
+2. **Si `--build`**: invocar `build_cpp_windows <app_name>` para compilar `cpp/build/windows/apps/<app_name>/<app_name>.exe`. Si falla, exit 1 sin tocar el Desktop.
+3. **Deploy**: invocar `deploy_cpp_exe_to_windows "<app_name>" "<app_dir>"`. Esta función mata el proceso si está vivo (taskkill.exe pre-autorizado), copia exe + DLLs + assets + runtime + enrichers, y preserva `local_files/`.
+4. **Launch**: invocar `launch_cpp_app_windows "<app_name>"` para arrancar la app en Windows.
+5. **Wait**: `sleep 1` — espera arranque corto.
+6. **Verify**: invocar `is_cpp_app_running_windows "<app_name>"`. Si NO está vivo → exit 1 con mensaje claro.
+7. **Stdout final**: `OK: <app_name> redeployed (build=yes/no, PID=N)`.
+
+## Argumentos
+
+- `app_name` — obligatorio. Nombre corto de la app.
+- `app_dir` — obligatorio. Ruta absoluta al directorio fuente (donde vive `app.md`, `enrichers/`, `runtime/`).
+- `--build` — opcional. Activa la compilación antes del deploy.
+
+## Errores
+
+Cada paso es punto de fallo independiente. En caso de error el pipeline imprime a stderr indicando qué paso falló y hace exit 1:
+
+- `ERROR [build]: build_cpp_windows falló` — fallo de compilación.
+- `ERROR [deploy]: deploy_cpp_exe_to_windows falló` — fallo al copiar archivos.
+- `ERROR [launch]: launch_cpp_app_windows falló` — la app no arrancó.
+- `ERROR [verify]: <app> no está corriendo` — la app arrancó pero murió antes de 1s.
+
+## Notas
+
+- Ahorra ~6 comandos manuales por redeploy (taskkill + cp + cd + start + sleep + tasklist). Motivación: issue 0086 — maximizar `Reg %` registrando esta secuencia como pipeline trazable.
+- Cada `fn run redeploy_cpp_app_windows_bash_pipelines` queda registrado en `call_monitor/operations.db`, alimentando las métricas del bucle reactivo.
+- `launch_cpp_app_windows_bash_infra` e `is_cpp_app_running_windows_bash_infra` son creadas por un fn-constructor paralelo. Si aún no existen en el registry al indexar, el indexer lo registra como advertencia pero el pipeline es válido structuralmente.
+- Tag `launcher` incluido: este pipeline tiene sentido en el Pipeline Launcher TUI (`apps/pipeline_launcher`) — es un workflow interactivo lanzable con argumentos.

bash/functions/pipelines/redeploy_cpp_app_windows.sh

@@ -0,0 +1,92 @@
+#!/usr/bin/env bash
+# redeploy_cpp_app_windows — Pipeline orquestador: build (opcional) + deploy + launch + verify
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$SCRIPT_DIR/../infra/build_cpp_windows.sh"
+source "$SCRIPT_DIR/../infra/deploy_cpp_exe_to_windows.sh"
+source "$SCRIPT_DIR/../infra/launch_cpp_app_windows.sh"
+source "$SCRIPT_DIR/../infra/is_cpp_app_running_windows.sh"
+
+redeploy_cpp_app_windows() {
+    local app_name=""
+    local app_dir=""
+    local do_build=0
+
+    # Parsear argumentos posicionales y flags
+    while [[ $# -gt 0 ]]; do
+        case "$1" in
+            --build)
+                do_build=1
+                shift
+                ;;
+            -*)
+                echo "redeploy_cpp_app_windows: flag desconocido: $1" >&2
+                return 1
+                ;;
+            *)
+                if [[ -z "$app_name" ]]; then
+                    app_name="$1"
+                elif [[ -z "$app_dir" ]]; then
+                    app_dir="$1"
+                else
+                    echo "redeploy_cpp_app_windows: argumento inesperado: $1" >&2
+                    return 1
+                fi
+                shift
+                ;;
+        esac
+    done
+
+    if [[ -z "$app_name" || -z "$app_dir" ]]; then
+        echo "redeploy_cpp_app_windows: uso: redeploy_cpp_app_windows <app_name> <app_dir> [--build]" >&2
+        return 1
+    fi
+
+    # Paso 1: build opcional
+    if [[ $do_build -eq 1 ]]; then
+        echo "[1/4] Building $app_name for Windows..."
+        if ! build_cpp_windows "$app_name"; then
+            echo "ERROR [build]: build_cpp_windows falló para '$app_name'" >&2
+            return 1
+        fi
+        echo "[1/4] Build OK"
+    else
+        echo "[1/4] Build skipped (--build no especificado)"
+    fi
+
+    # Paso 2: deploy (taskkill + copy exe/DLLs/assets/runtime + preserva local_files)
+    echo "[2/4] Deploying $app_name to Windows Desktop..."
+    if ! deploy_cpp_exe_to_windows "$app_name" "$app_dir"; then
+        echo "ERROR [deploy]: deploy_cpp_exe_to_windows falló para '$app_name'" >&2
+        return 1
+    fi
+    echo "[2/4] Deploy OK"
+
+    # Paso 3: lanzar la app
+    echo "[3/4] Launching $app_name..."
+    if ! launch_cpp_app_windows "$app_name"; then
+        echo "ERROR [launch]: launch_cpp_app_windows falló para '$app_name'" >&2
+        return 1
+    fi
+    echo "[3/4] Launch OK"
+
+    # Paso 4: esperar arranque y verificar
+    sleep 1
+    echo "[4/4] Verifying $app_name is running..."
+    local pid=""
+    if ! pid=$(is_cpp_app_running_windows "$app_name"); then
+        echo "ERROR [verify]: $app_name no está corriendo tras el lanzamiento. Revisa logs en Desktop/apps/$app_name/." >&2
+        return 1
+    fi
+    echo "[4/4] Running OK"
+
+    local build_label="no"
+    [[ $do_build -eq 1 ]] && build_label="yes"
+    echo "OK: $app_name redeployed (build=$build_label, PID=$pid)"
+}
+
+# Ejecutar si se llama directamente (fn run lo invoca como script)
+if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
+    redeploy_cpp_app_windows "$@"
+fi