diff --git a/.claude/commands/compile.md b/.claude/commands/compile.md
new file mode 100644
index 00000000..873f3378
--- /dev/null
+++ b/.claude/commands/compile.md
@@ -0,0 +1,165 @@
+# /compile — Compila la app actual y la copia al escritorio de Windows
+
+Compila una app del registry para los targets que soporte (Windows via MinGW, Android via Gradle/NDK si esta configurado) y deja el resultado en `/mnt/c/Users/lucas/Desktop/apps/<app>/`, listo para usar desde Windows.
+
+Pensado para apps C++ del workspace `cpp/` (donde ya hay toolchain `mingw-w64.cmake` y build dir `cpp/build/windows/`). Si en el futuro hay apps Android (Gradle wrapper o NDK), tambien las detecta.
+
+## Argumento
+
+`$ARGUMENTS` — opcional. Nombre de la app a compilar (ej: `chart_demo`, `registry_dashboard`).
+
+- Sin argumento: detectar la app desde `pwd` (si estas dentro de `cpp/apps/<X>/` o `projects/*/apps/<X>/`).
+- Si no hay app deducible y no se pasa argumento → listar apps disponibles y pedir nombre.
+- Si se pasa argumento, usarlo directamente.
+
+## Pasos
+
+### 1. Resolver la app y su directorio fuente
+
+```bash
+ROOT=/home/lucas/fn_registry
+APP_ARG="$ARGUMENTS"
+
+# Detectar desde CWD si no hay argumento
+if [ -z "$APP_ARG" ]; then
+  CWD="$(pwd)"
+  case "$CWD" in
+    "$ROOT"/cpp/apps/*|"$ROOT"/projects/*/apps/*)
+      APP_ARG="$(basename "$CWD")" ;;
+  esac
+fi
+
+# Si sigue vacio, listar apps y abortar
+if [ -z "$APP_ARG" ]; then
+  echo "Apps disponibles:"
+  ls "$ROOT"/cpp/apps/ 2>/dev/null
+  ls "$ROOT"/projects/*/apps/ 2>/dev/null
+  echo "Uso: /compile <app_name>"
+  exit 1
+fi
+
+# Buscar el directorio real
+APP_DIR=""
+for cand in "$ROOT/cpp/apps/$APP_ARG" "$ROOT"/projects/*/apps/"$APP_ARG"; do
+  [ -d "$cand" ] && APP_DIR="$cand" && break
+done
+
+if [ -z "$APP_DIR" ]; then
+  echo "No encuentro app '$APP_ARG' en cpp/apps/ ni projects/*/apps/"
+  exit 1
+fi
+echo "App: $APP_ARG"
+echo "Dir: $APP_DIR"
+```
+
+### 2. Detectar targets soportados
+
+Examinar el `app.md` y los archivos del directorio para decidir que se puede compilar:
+
+- **Windows (MinGW)**: si la app tiene `CMakeLists.txt` y se registra en `cpp/CMakeLists.txt` (es decir, aparece como subdirectorio en `cpp/build/windows/apps/<APP>/`). Default para apps C++.
+- **Android**: si existe `AndroidManifest.xml`, `build.gradle`, `build.gradle.kts` o carpeta `android/` dentro de `$APP_DIR`. (Hoy no hay ninguna; saltar silenciosamente.)
+- **Linux** (opcional, no por defecto): el build dir `cpp/build/` ya genera el binario para Linux. Solo se hace si el usuario lo pide explicitamente.
+
+```bash
+TARGETS=()
+[ -f "$APP_DIR/CMakeLists.txt" ] && TARGETS+=("windows")
+
+if [ -f "$APP_DIR/AndroidManifest.xml" ] || \
+   [ -f "$APP_DIR/build.gradle" ] || \
+   [ -f "$APP_DIR/build.gradle.kts" ] || \
+   [ -d "$APP_DIR/android" ]; then
+  TARGETS+=("android")
+fi
+
+if [ ${#TARGETS[@]} -eq 0 ]; then
+  echo "No se detecta ningun target compilable en $APP_DIR"
+  exit 1
+fi
+echo "Targets: ${TARGETS[*]}"
+```
+
+### 3. Compilar Windows (cross-compile MinGW)
+
+Solo si `windows` esta en TARGETS.
+
+```bash
+BUILD_WIN="$ROOT/cpp/build/windows"
+
+# Configurar build dir si no existe
+if [ ! -f "$BUILD_WIN/CMakeCache.txt" ]; then
+  mkdir -p "$BUILD_WIN"
+  cmake -S "$ROOT/cpp" -B "$BUILD_WIN" \
+    -DCMAKE_TOOLCHAIN_FILE="$ROOT/cpp/toolchains/mingw-w64.cmake" \
+    -DCMAKE_BUILD_TYPE=Release
+fi
+
+# Compilar SOLO el target de la app (no todo el arbol)
+cmake --build "$BUILD_WIN" --target "$APP_ARG" -j"$(nproc)"
+```
+
+Si el target no existe en CMake (porque la app no esta registrada en `cpp/CMakeLists.txt`), reportar y proponer registrarla siguiendo `cpp_apps.md` §5. NO autoregistrarla sin confirmacion del usuario.
+
+### 4. Copiar a `/mnt/c/Users/lucas/Desktop/apps/<APP>/`
+
+Replica el flujo documentado en memoria (`feedback_no_adminlocal.md`): el `.exe` + las TTFs de fuentes que el shell ImGui necesita. NO usar `AdminLocal`.
+
+```bash
+DEST="/mnt/c/Users/lucas/Desktop/apps/$APP_ARG"
+mkdir -p "$DEST"
+
+EXE_SRC="$BUILD_WIN/apps/$APP_ARG/$APP_ARG.exe"
+if [ ! -f "$EXE_SRC" ]; then
+  echo "ERROR: no se ha generado $EXE_SRC"
+  exit 1
+fi
+
+cp -v "$EXE_SRC" "$DEST/"
+
+# TTFs (estan junto al exe tras el build, copiados por add_imgui_app)
+for ttf in "$BUILD_WIN/apps/$APP_ARG"/*.ttf; do
+  [ -f "$ttf" ] && cp -v "$ttf" "$DEST/"
+done
+
+# Assets opcionales (carpeta assets/ junto al exe del build)
+if [ -d "$BUILD_WIN/apps/$APP_ARG/assets" ]; then
+  rsync -a --delete "$BUILD_WIN/apps/$APP_ARG/assets/" "$DEST/assets/"
+fi
+
+echo "OK: $APP_ARG -> $DEST"
+```
+
+### 5. Compilar Android (solo si TARGETS contiene `android`)
+
+Hoy no hay apps Android en el registry, asi que esta rama no se ejecuta. Cuando se anada la primera, este es el patron previsto:
+
+```bash
+if [[ " ${TARGETS[*]} " == *" android "* ]]; then
+  ANDROID_DIR="$APP_DIR"
+  [ -d "$APP_DIR/android" ] && ANDROID_DIR="$APP_DIR/android"
+
+  cd "$ANDROID_DIR"
+  if [ -x "./gradlew" ]; then
+    ./gradlew assembleRelease
+    APK="$(find "$ANDROID_DIR/app/build/outputs/apk/release" -name '*.apk' | head -n1)"
+    [ -n "$APK" ] && cp -v "$APK" "/mnt/c/Users/lucas/Desktop/apps/$APP_ARG/"
+  else
+    echo "android: no hay ./gradlew en $ANDROID_DIR — saltando."
+  fi
+fi
+```
+
+Cuando llegue la primera app Android, este bloque puede ampliarse (firma, ABI splits, etc.).
+
+### 6. Resumen
+
+Imprime al final una linea por target con:
+- Tamano del binario (`ls -lh`)
+- Path final en `/mnt/c/Users/lucas/Desktop/apps/<APP>/`
+- Nombre del exe/apk
+
+## Notas
+
+- El build de Windows usa `cpp/build/windows/` (no `cpp/build/`). El de Linux es `cpp/build/`. Coexisten sin conflicto.
+- El toolchain `mingw-w64.cmake` ya configura linkado estatico (`-static-libgcc -static-libstdc++ -lwinpthread`) — el `.exe` resultante es self-contained y no necesita DLLs en el escritorio.
+- Si se pasa una app que vive en `projects/<proj>/apps/<APP>/`, el target CMake sigue siendo `<APP>` (registrado en `cpp/CMakeLists.txt` con `add_subdirectory(${PROJ_DIR}/apps/<APP> ${CMAKE_BINARY_DIR}/apps/<APP>)`).
+- NO tocar `AdminLocal` ni instalar nada en `Program Files` — solo el escritorio del usuario.