kcreate-scaffolding-gcp-script 0.2.0 → 0.2.1

package/README.md

@@ -24,7 +24,6 @@ El despliegue es un proceso aparte, posterior y manual.
 | `README.md` (este) | Manual de usuario: qué hace, cómo se instala y cómo se usa. |
 | [`AGENT.md`](AGENT.md) | Guía operativa para agentes de IA: ciclo completo, contrato de exit codes, fallas comunes, receta de validación. |
 | [`CONTRIBUTING.md`](CONTRIBUTING.md) | Flujo de contribución, convenciones e invariantes del código. |
-| [`DeployNPM.md`](DeployNPM.md) | Manual operativo para publicar el paquete npm (comandos exactos, autenticación con OTP, verificación y errores comunes). |
 | [`CHANGELOG.md`](CHANGELOG.md) | Historia de versiones (Keep a Changelog). |
 | [`IDEA.md`](IDEA.md) | Especificación de origen del skill. |
 | [`kcreate-scaffolding-gcp-script/SKILL.md`](kcreate-scaffolding-gcp-script/SKILL.md) | Instrucciones del agente, etapa por etapa (lo que ejecuta el skill instalado). |
@@ -44,42 +43,89 @@ diseño evita está en
 
 ## Instalación
 
-Hay dos instaladores **intercambiables**: dejan exactamente el mismo
-resultado en el repo destino (mismos archivos, mismos permisos, mismos exit
-codes). Elige el que te acomode.
+Hay dos instaladores **intercambiables** (`npx` y `install.sh`): dejan
+exactamente el mismo resultado en el repo destino (mismos archivos, mismos
+permisos, mismos exit codes). Elige el que te acomode.
 
 En ambos casos se instala el skill (+ su dependencia
 [`github-proyect-tracking`](https://github.com/kronops/KGithubTracking),
 vendorizada en `vendor/`) en el repo donde se va a usar, como skill de
 proyecto de Claude Code.
 
-### Opción A — `npx` (sin instalar el skill a mano)
+| Vía | Cuándo usarla | Requisitos |
+|---|---|---|
+| **A — `npx`** (paquete publicado en npm) | La normal: no hay que clonar este repo. | Node ≥ 18 |
+| **A-bis — `npx` sobre un tarball** | Sin acceso al registro, o para probar una versión local antes de publicarla. | Node ≥ 18 + copia de este repo |
+| **B — `install.sh`** | Prefieres bash puro, o trabajas con el repo ya clonado. | bash + git |
 
-Si el paquete está en el registro de npm (o tienes el tarball):
+### Opción A — `npx` (recomendada, sin clonar el repo)
+
+El paquete está publicado en el registro público de npm como
+[`kcreate-scaffolding-gcp-script`](https://www.npmjs.com/package/kcreate-scaffolding-gcp-script)
+(versión actual: `0.2.1`). Único requisito: **Node ≥ 18** (`npx` viene con
+npm). El instalador no tiene dependencias npm; el skill en sí no usa Node:
+es bash + Python 3.8+ stdlib.
 
 ```bash
+# 0) (opcional) diagnóstico: no modifica nada, solo reporta el estado del destino
+npx --yes kcreate-scaffolding-gcp-script doctor --target-repo /ruta/a/tu/repo-de-infra
+
+# 1) instalar el skill en el repo destino
 npx --yes kcreate-scaffolding-gcp-script --target-repo /ruta/a/tu/repo-de-infra
-npx --yes ./kcreate-scaffolding-gcp-script-0.2.0.tgz --target-repo /ruta/a/tu/repo-de-infra
 ```
 
-Generar el tarball desde una copia del repo:
+Salida esperada del paso 1:
+
+```
+[OK] kcreate-scaffolding-gcp-script instalado en <repo>/.claude/skills/kcreate-scaffolding-gcp-script
+[OK] github-proyect-tracking instalado en <repo>/.claude/skills/github-proyect-tracking
+[OK] Instalación completa en <repo>
+```
+
+Notas de uso:
+
+- `--yes` evita el prompt de npx (`Need to install the following packages`)
+  la primera vez. `npx` cachea el paquete, así que las siguientes corridas son
+  instantáneas.
+- Para instalaciones reproducibles fija la versión:
+  `npx --yes kcreate-scaffolding-gcp-script@0.2.1 --target-repo <repo>`. Sin
+  sufijo toma `latest`.
+- **Actualizar** = volver a correr el mismo comando con `--force`. Sin
+  `--force`, una instalación existente nunca se toca: termina con
+  `[ERROR] No se instaló nada…` y **exit 1**.
+- También sirve instalarlo global: `npm install -g kcreate-scaffolding-gcp-script`
+  y después `kcreate-scaffolding-gcp-script --target-repo <repo>`.
+- Ayuda y versión del instalador: `npx --yes kcreate-scaffolding-gcp-script --help`
+  y `--version` (hoy responde `kcreate-scaffolding-gcp-script/0.2.1 (instalador npx)`).
+
+> `npx ... github:kronops/KCreateScaffoldingGCPScripts` **no** sirve: npm
+exige el `package.json` en la raíz del repo y aquí vive en `npm/` (npm no
+soporta subdirectorios en dependencias git). Por eso la opción `npx` usa el
+paquete del registro o un tarball local.
+
+### Opción A-bis — `npx` sobre un tarball local
+
+Para probar una versión que aún no está publicada (o sin red):
 
 ```bash
 git clone git@github-work:kronops/KCreateScaffoldingGCPScripts.git
 cd KCreateScaffoldingGCPScripts/npm
 npm pack          # prepack empaqueta skill/ + vendor/ + README + LICENSE
-npx --yes ./kcreate-scaffolding-gcp-script-0.2.0.tgz --target-repo /ruta/a/tu/repo
+npx --yes ./kcreate-scaffolding-gcp-script-0.2.1.tgz --target-repo /ruta/a/tu/repo-de-infra
 ```
 
-Requisitos del instalador npx: **Node ≥ 18** (cero dependencias npm). El skill
-en sí no usa Node: es bash + Python 3.8+ stdlib.
+Detalle que muerde: `npx` solo acepta el tarball con ruta **relativa con
+`./`** o como URL `file:`. Una ruta absoluta "pelada"
+(`npx /tmp/x.tgz`) falla con `sh: Permission denied` y **exit 126**:
 
-> `npx ... github:kronops/KCreateScaffoldingGCPScripts` **no** sirve: npm
-exige el `package.json` en la raíz del repo y aquí vive en `npm/` (npm no
-soporta subdirectorios en dependencias git). Por eso la opción `npx`
-requiere el paquete publicado o un tarball local.
+```bash
+# mal
+npx --yes /tmp/kcreate-scaffolding-gcp-script-0.2.1.tgz --target-repo /ruta/al/repo
+# bien
+npx --yes "file:/tmp/kcreate-scaffolding-gcp-script-0.2.1.tgz" --target-repo /ruta/al/repo
+```
 
-### Opción B — clonando el repo
+### Opción B — clonando el repo (`install.sh`)
 
 ```bash
 git clone git@github-work:kronops/KCreateScaffoldingGCPScripts.git
@@ -87,7 +133,7 @@ cd KCreateScaffoldingGCPScripts
 ./install.sh --target-repo /ruta/a/tu/repo-de-infra
 ```
 
-### Resultado (idéntico en ambas opciones)
+### Resultado (idéntico en las tres vías)
 
 ```
 <tu-repo>/.claude/skills/
@@ -100,6 +146,14 @@ skill asume la convención `live/<entorno>/<componente>/terragrunt.hcl`) pero
 igual instala: la herramienta sirve para cualquier repo, aunque falle al
 usarse.
 
+### Exit codes del instalador npx
+
+| Exit | Significado |
+|---|---|
+| `0` | El skill quedó instalado/actualizado en el destino. |
+| `1` | No se instaló nada: el skill ya existía sin `--force`, el destino no existe o no es la raíz de un repo git. |
+| `2` | Argumentos inválidos (falta `--target-repo`, flag desconocido, comando desconocido). |
+
 ### Flags
 
 Los mismos nombres y semántica en `install.sh` y en el instalador npx:
@@ -141,15 +195,15 @@ listando los requisitos faltantes.
 
 ### Publicar el paquete npm (mantenedores)
 
-El procedimiento completo — y los comandos exactos, uno por uno — está en
-[`DeployNPM.md`](DeployNPM.md). Resumen:
+El paquete está publicado y su mantenedor es `kronops`. Procedimiento:
 
 ```bash
 cd npm
-npm whoami                     # ¿hay sesión? (hoy: E401, hay que loguearse)
+npm whoami                     # ¿hay sesión? (si da E401, hay que loguearse)
 npm login --auth-type=legacy   # usuario, password, email y, si la cuenta tiene 2FA, OTP
 npm publish --dry-run          # ensayo obligatorio: construye el tarball sin subir nada
 npm publish                    # publicar (con 2FA: npm publish --otp=123456)
+npm view kcreate-scaffolding-gcp-script version   # confirmar la versión en el registro
 ```
 
 Ojo: si la cuenta tiene 2FA, el login por navegador **no** sirve sin GUI; hay
@@ -163,7 +217,7 @@ nunca se comitean. Prueba local sin publicar:
 
 ```bash
 cd npm && npm pack
-npx --yes ./kcreate-scaffolding-gcp-script-0.2.0.tgz --target-repo /ruta/al/repo
+npx --yes ./kcreate-scaffolding-gcp-script-0.2.1.tgz --target-repo /ruta/al/repo
 ```
 
 Para subir una versión nueva: `node -p "require('./package.json').version"`,
@@ -273,8 +327,9 @@ $S/02_print_config.sh  xoloshop-prod                # revisar antes de construir
 
 $S/10_build_components.sh xoloshop-prod             # construcción
 
-$S/20_validate_file_parity.sh      boletera-qa xoloshop-prod
-$S/21_validate_project_pinning.sh  xoloshop-prod
+$S/20_validate_file_parity.sh           boletera-qa xoloshop-prod
+$S/21_validate_project_pinning.sh       xoloshop-prod
+$S/22_validate_no_app_name_leftover.sh  xoloshop-prod
 ```
 
 Cada script termina con un mensaje de una sola línea y un código de salida
@@ -292,6 +347,7 @@ acorde — pensado para scripting, no solo para lectura humana:
 | `10_build_components.sh` | `BUILD_OK: <ruta>` | — | `BUILD_FAILED: <paso> - <detalle>` | — |
 | `20_validate_file_parity.sh` | `FILE_PARITY_OK: <n>` | — | `FILE_PARITY_MISMATCH` | — |
 | `21_validate_project_pinning.sh` | `PROJECT_PINNING_OK: <n>` | — | `PROJECT_PINNING_FAILED` | — |
+| `22_validate_no_app_name_leftover.sh` | `APP_NAME_LEFTOVER_OK` | — | `APP_NAME_LEFTOVER_FOUND: <n>` | — |
 | `run_tracking.sh` | comando OK | — | error de tracking | tracking no instalado |
 
 `2` no es un error: es la señal de "faltan datos, llénalos y vuelve a correr
@@ -302,7 +358,6 @@ el mismo comando".
 ```
 KCreateScaffoldingGCPScripts/
 ├── README.md / AGENT.md / CONTRIBUTING.md / CHANGELOG.md
-├── DeployNPM.md                   # manual para publicar el paquete en npm
 ├── IDEA.md                        # especificación de origen del skill
 ├── CreateScriptsNewGCPProjectInstructions.md  # guía manual de referencia (base de experiencia)
 ├── LICENSE                        # MIT
@@ -324,8 +379,9 @@ KCreateScaffoldingGCPScripts/
         ├── 01_init_config.sh      # Pre requisitos, paso 1
         ├── 02_print_config.sh     # Pre requisitos, paso 2
         ├── 10_build_components.sh # Construcción
-        ├── 20_validate_file_parity.sh      # Validación 1
-        ├── 21_validate_project_pinning.sh  # Validación 2
+        ├── 20_validate_file_parity.sh           # Validación 1
+        ├── 21_validate_project_pinning.sh       # Validación 2
+        ├── 22_validate_no_app_name_leftover.sh  # Validación 3
         └── run_tracking.sh        # envoltura sobre github-proyect-tracking
 ```
 
@@ -341,10 +397,13 @@ KCreateScaffoldingGCPScripts/
 - El instalador npx **no** puede consumirse como
   `npx github:kronops/KCreateScaffoldingGCPScripts`: npm exige el
   `package.json` en la raíz del repo y aquí vive en `npm/` (no soporta
-  subdirectorios en dependencias git). Requiere publicación en el registro
-  de npm o un tarball local (`npm pack`).
-- `npm publish` está preparado pero el paquete aún no está publicado en el
-  registro; hoy la vía sin clonar el repo es el tarball.
+  subdirectorios en dependencias git). Por eso se publica en el registro y
+  se instala como `npx kcreate-scaffolding-gcp-script`, o vía tarball local
+  (`npm pack`).
+- El paquete del registro se actualiza solo cuando alguien corre
+  `npm publish` a mano: un cambio en este repo no llega a los usuarios de
+  `npx` hasta que sube la versión (y una versión publicada no se reutiliza,
+  `E409`).
 - El nombre del proyecto (`PROJECT_NAME`, ej. `Xoloshop-Prod`) se infiere de
   `NEW_ENV` con la convención `<App>-<QA|Prod>`; si la app tiene siglas o una
   capitalización no obvia, corrígelo a mano en el config antes de construir.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kcreate-scaffolding-gcp-script",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Instalador npx del skill kcreate-scaffolding-gcp-script: genera el scaffolding de Terragrunt para un entorno GCP nuevo a partir de uno existente.",
   "bin": {
     "kcreate-scaffolding-gcp-script": "bin/cli.js"

package/skill/SKILL.md

@@ -182,12 +182,13 @@ el resultado final; no las descartes en silencio.
 
 ## Etapa 3 — Validación
 
-Dos scripts, cualquier orden, ambos obligatorios antes de dar por bueno
-el resultado:
+Tres scripts, cualquier orden, los tres obligatorios antes de dar por
+bueno el resultado:
 
 ```bash
 .claude/skills/kcreate-scaffolding-gcp-script/scripts/20_validate_file_parity.sh <SOURCE_ENV> <NEW_ENV>
 .claude/skills/kcreate-scaffolding-gcp-script/scripts/21_validate_project_pinning.sh <NEW_ENV>
+.claude/skills/kcreate-scaffolding-gcp-script/scripts/22_validate_no_app_name_leftover.sh <NEW_ENV>
 ```
 
 - `20_validate_file_parity.sh` → `FILE_PARITY_OK` (exit 0) o
@@ -199,17 +200,32 @@ el resultado:
   problema). Confirma que, sin importar qué proyecto tenga `gcloud` como
   default en ese momento, cada componente de `NEW_ENV` resuelve siempre al
   proyecto correcto.
-
-SI cualquiera de los dos falla → `DETENTE`. No es un error de Terragrunt
+- `22_validate_no_app_name_leftover.sh` → `APP_NAME_LEFTOVER_OK` (exit 0) o
+  `APP_NAME_LEFTOVER_FOUND` (exit 1, con archivo y línea exactos). Busca el
+  nombre corto de la app de `SOURCE_ENV` (sin el sufijo `-qa`/`-prod`/etc.),
+  en cualquier capitalización, en cualquier archivo de `live/<NEW_ENV>/`.
+  Complementa a `21`: un nombre de marca estilizado (ej. "XoloShop", con
+  una mayúscula interna) no es substring de "xoloshop-qa" ni de
+  "Xoloshop-QA", así que `21` no lo detecta — pero sí es un leftover real
+  del entorno fuente que no debe quedar en el nuevo.
+
+SI cualquiera de los tres falla → `DETENTE`. No es un error de Terragrunt
 ni de GCP — es un defecto de generación real, y el mensaje ya dice
 exactamente qué componente/archivo revisar.
 
-SI ambos pasan y el tracking SÍ se inicializó en la Etapa 2 (no viste el
+SI los tres pasan y el tracking SÍ se inicializó en la Etapa 2 (no viste el
 `[WARN]` de "no se pudo inicializar github-proyect-tracking") → marca el
-proceso como terminado:
+proceso como terminado. Antes de llamar a `finalize`, construye el mismo
+resumen de ejecución que vas a mostrarle al humano (paso 1 de la lista de
+abajo) y escríbelo en un archivo de texto plano — ese archivo se publica
+como un comentario aparte en el Issue, después del de FINALIZADO y antes
+de cerrarlo, para que quien lea el Issue no tenga que pedírtelo por fuera:
 
 ```bash
-.claude/skills/kcreate-scaffolding-gcp-script/scripts/run_tracking.sh finalize "$(ls -d .kcreate-scaffolding/<NEW_ENV>.config)"
+cat > /tmp/kcreate-resumen-<NEW_ENV>.txt <<'EOF'
+<el mismo resumen de ejecución del paso 1 de abajo>
+EOF
+.claude/skills/kcreate-scaffolding-gcp-script/scripts/run_tracking.sh finalize "$(ls -d .kcreate-scaffolding/<NEW_ENV>.config)" /tmp/kcreate-resumen-<NEW_ENV>.txt
 ```
 
 SI el tracking nunca se inicializó (modo best-effort sin éxito, ver

package/skill/references/lessons-learned.md

@@ -1,6 +1,6 @@
 # Lecciones reales incorporadas en este skill
 
-Cinco fuentes:
+Seis fuentes:
 
 - **A — descubiertas desplegando `xoloshop-qa` a mano** (sesión previa,
   documentadas también en `docs/CreateScriptsNewGCPProjectInstructions.md`
@@ -25,6 +25,10 @@ Cinco fuentes:
   propio fix de `artifact_registry` (una función nueva de esa misma
   ronda) se había quedado con la misma contaminación que D1/D2 ya habían
   corregido en las demás. Ver `Review_V3.md`.
+- **F — encontradas ejecutando el skill de punta a punta contra el repo
+  real `club-tijuana/infra-cloud`** (no una copia descartable), generando
+  `coreservices-qa` desde `xoloshop-qa`, con Issue de tracking real
+  creado y cerrado.
 
 Cada lección dice **qué pasaba**, **por qué**, y **en qué script/función
 de este skill queda resuelta**.
@@ -611,6 +615,85 @@ excluye" pase sin ninguna pista de la causa.
 
 ---
 
+## F — encontradas ejecutando el skill de punta a punta contra `infra-cloud` real
+
+A diferencia de B-E (copias descartables), esta corrida fue real: generó
+`coreservices-qa` desde `xoloshop-qa` en `club-tijuana/infra-cloud`, con
+Issue de tracking real (#332) creado y cerrado. El usuario revisó el
+resultado campo por campo y reportó F1 directamente.
+
+### F1 — "XoloShop" (marca estilizada) sobrevivía la sustitución, sin ser detectado
+
+**Qué pasaba:** `service_accounts/terragrunt.hcl`, generado desde
+`xoloshop-qa`, dejó `display_name`/`description` de dos service accounts
+con "XoloShop" (S interna mayúscula) sin tocar — debían decir
+"Coreservices QA ...". `ksc_copy_component_files` solo hacía dos pasadas
+de sustitución EXACTAS: `ksc_substr_replace` para `"xoloshop"` (minúsculas)
+y una para `ksc_capitalize("xoloshop")` = `"Xoloshop"` (solo la primera
+letra). Ninguna de las dos es substring de `"XoloShop"` (mayúscula
+*interna*), así que esa capitalización en particular pasaba intacta.
+Tampoco `21_validate_project_pinning.sh` lo atrapaba: busca el token
+completo `"<app>-<entorno>"` exacto, y `"XoloShop"` no es substring de
+`"xoloshop-qa"` ni de `"Xoloshop-QA"`.
+**Resuelto en:**
+- `lib/common.sh:ksc_substr_replace_app` — sustitución case-*insensitive*
+  (vía `re.IGNORECASE` en Python) con reemplazo case-*aware*: si el match
+  original era todo mayúsculas usa `APP_NEW` en mayúsculas, si era todo
+  minúsculas usa minúsculas, cualquier otro caso (incluida la "XoloShop"
+  original) usa capitalización simple (`Coreservices`). Así cualquier
+  variante de capitalización del nombre de marca queda cubierta, no solo
+  las dos que `ksc_capitalize` sabía producir.
+- `10_build_components.sh:ksc_copy_component_files` — reemplaza las dos
+  pasadas exactas por una llamada a `ksc_substr_replace_app` (solo si
+  `APP_SOURCE != APP_NEW`, evitando trabajo innecesario cuando el nombre
+  de app no cambia entre entornos).
+- `build_component_artifact_registry`'s detección de "ya es genérico" —
+  cambiada a `grep -qi` por la misma razón (consistencia: no tiene sentido
+  que la detección sea case-sensitive si la sustitución ya no lo es).
+  **Decisión explícita de NO tocar:** el check de `repository_id` en
+  `ksc_learn_artifact_registry_template` sigue siendo exacto/minúsculas —
+  GCP exige minúsculas en ese campo, así que ahí la sensibilidad a mayúsculas
+  es correcta, no un bug.
+- **Nueva validación:** `22_validate_no_app_name_leftover.sh` — un script
+  de Etapa 3 dedicado, que busca `APP_SOURCE` (cualquier capitalización)
+  en TODO archivo de `live/<NEW_ENV>/`, fuera de comentarios. Complementa
+  (no reemplaza) a `21`: ese sigue validando el token completo exacto,
+  este cubre justo el caso que `21` no puede ver por diseño. Probado
+  contra una copia descartable: pasa limpio en un build correcto, y
+  detecta correctamente un leftover reintroducido a mano, reportando
+  archivo y línea exactos.
+
+### F2 — El tracking no decía qué skill lo estaba usando ni con qué parámetros
+
+**Qué pasaba:** el Issue de GitHub que abre `github-proyect-tracking` no
+tenía forma de decir, por sí solo, que lo estaba usando
+`/kcreate-scaffolding-gcp-script`, ni con qué `SOURCE_ENV`/`NEW_ENV` —
+alguien leyendo el Issue sin contexto previo no podía saber qué se estaba
+construyendo sin preguntar aparte.
+**Resuelto:** `github-proyect-tracking` 0.7.0+ agrega `--process-name`/
+`--process-inputs` a `init` (ver `vendor/VENDORED_FROM.md`); este skill
+los manda siempre, automáticamente, desde `run_tracking.sh init-plan`
+(`--process-name "/kcreate-scaffolding-gcp-script"` y
+`--process-inputs '{"SOURCE_ENV":...,"NEW_ENV":...}'`), sin que el agente
+tenga que acordarse de pasarlos.
+
+### F3 — El resumen final solo se veía en pantalla, no quedaba en el Issue
+
+**Qué pasaba:** al terminar, el agente comentaba "FINALIZADO" en el Issue
+y lo cerraba, pero el resumen de ejecución (lo que sí le mostraba al
+humano en pantalla) nunca quedaba escrito en el Issue — quien lo leyera
+después no tenía ese resumen, solo el estado final.
+**Resuelto:** `github-proyect-tracking` 0.7.0 agrega `finalize
+--summary`/`--summary-file`, que publica un comentario aparte con el
+resumen DESPUÉS del de FINALIZADO y ANTES de cerrar el Issue (orden
+verificado con pruebas unitarias dedicadas, incluyendo que la ruta
+`--force`/CANCELADO nunca publica resumen). `run_tracking.sh finalize`
+acepta ahora un tercer argumento opcional (ruta a un archivo con el
+resumen); `SKILL.md` (Etapa 3) ya le indica al agente que construya ese
+resumen ANTES de llamar a `finalize` y lo pase como archivo.
+
+---
+
 ## Qué significa esta lista para quien edite este skill después
 
 Cada vez que se agregue un `build_component_<algo>` nuevo o se modifique

package/skill/scripts/10_build_components.sh

@@ -49,7 +49,6 @@ NEW_DIR="$REPO_ROOT/live/$NEW_ENV"
 
 read -r APP_SOURCE ENTORNO_SOURCE < <(ksc_split_env "$SOURCE_ENV")
 read -r APP_NEW ENTORNO_NEW < <(ksc_split_env "$NEW_ENV")
-APP_SOURCE_CAP="$(ksc_capitalize "$APP_SOURCE")"
 APP_NEW_CAP="$(ksc_capitalize "$APP_NEW")"
 
 CIDR_FILE="$(ksc_cidr_file_path "$REPO_ROOT" "$NEW_ENV")"
@@ -169,17 +168,25 @@ ksc_copy_component_files() {
     [[ -f "$SOURCE_DIR/$comp/$f" ]] && cp "$SOURCE_DIR/$comp/$f" "$NEW_DIR/$comp/$f"
   done
   # Sustitución estándar aplicada a TODO componente, conocido o no: el
-  # token completo del entorno, y el nombre corto de la app (en minúscula
-  # y capitalizado). Antes esto solo se hacía a mano en algunos
-  # componentes — Review V1 (E-5) encontró texto real de SOURCE_ENV
-  # filtrado en service_accounts (display_name) y project_iam (namespace
-  # de un principal) porque esos dos nunca aplicaban la sustitución de
-  # nombre de app, solo la del token completo.
+  # token completo del entorno, y el nombre corto de la app en CUALQUIER
+  # capitalización (ver ksc_substr_replace_app). Antes esto solo se hacía
+  # a mano en algunos componentes — Review V1 (E-5) encontró texto real
+  # de SOURCE_ENV filtrado en service_accounts (display_name) y
+  # project_iam (namespace de un principal) porque esos dos nunca
+  # aplicaban la sustitución de nombre de app, solo la del token
+  # completo. Corregido ahí; después, un bug real encontrado usando el
+  # skill (no en revisión) mostró que la sustitución de nombre de app
+  # EXISTÍA pero solo cubría dos capitalizaciones exactas (minúscula y
+  # "Primera-mayúscula") — un nombre de marca estilizado como "XoloShop"
+  # (S interna mayúscula) no hacía match con ninguna de las dos y se
+  # colaba completo a service_accounts.display_name/description. Ver
+  # lessons-learned.md, sección F.
   f="$NEW_DIR/$comp/terragrunt.hcl"
   [[ -f "$f" ]] || return 0
   ksc_substr_replace "$f" "$SOURCE_ENV" "$NEW_ENV"
-  [[ "$APP_SOURCE" != "$APP_NEW" ]] && ksc_substr_replace "$f" "$APP_SOURCE" "$APP_NEW"
-  [[ "$APP_SOURCE_CAP" != "$APP_NEW_CAP" ]] && ksc_substr_replace "$f" "$APP_SOURCE_CAP" "$APP_NEW_CAP"
+  if [[ "$APP_SOURCE" != "$APP_NEW" ]]; then
+    ksc_substr_replace_app "$f" "$APP_SOURCE" "$APP_NEW"
+  fi
 }
 
 # ---------------------------------------------------------------------------
@@ -429,7 +436,12 @@ build_component_artifact_registry() {
   # era genérico (sin el nombre de la app), la sustitución automática no
   # tiene nada que reemplazar y el resultado seguiría siendo genérico.
   local was_generic=1
-  grep -q "$APP_SOURCE" "$SOURCE_DIR/artifact_registry/terragrunt.hcl" && was_generic=0
+  # -i: la app puede aparecer con cualquier capitalización (ver
+  # ksc_substr_replace_app) — un chequeo exacto-minúscula aquí marcaría
+  # "genérico" un archivo que en realidad sí tiene el nombre de la app
+  # (solo que estilizado, ej. "XoloShop"), y la sustitución automática de
+  # ksc_copy_component_files ya lo habría corregido de todas formas.
+  grep -qi "$APP_SOURCE" "$SOURCE_DIR/artifact_registry/terragrunt.hcl" && was_generic=0
 
   ksc_copy_component_files artifact_registry
 

package/skill/scripts/22_validate_no_app_name_leftover.sh

@@ -0,0 +1,62 @@
+#!/usr/bin/env bash
+# Etapa: Validación — script 3.
+# Busca, en TODO archivo de texto de live/<NEW_ENV>/, el nombre corto de
+# la app de SOURCE_ENV (sin el sufijo de entorno -qa/-prod/-dev/etc.),
+# en CUALQUIER capitalización. Complementa a 21_validate_project_pinning.sh
+# (que solo busca el token completo "<app>-<entorno>", exacto): un nombre
+# de marca estilizado como "XoloShop" (con una S interna mayúscula) no es
+# "xoloshop-qa" ni "Xoloshop-QA" como substring, así que 21 nunca lo
+# atrapa — y la sustitución de ksc_copy_component_files, si tiene un bug,
+# tampoco. Caso real: service_accounts generado desde xoloshop-qa dejó
+# "XoloShop" sin tocar en dos display_name/description, porque la
+# sustitución de entonces solo cubría "xoloshop" y "Xoloshop" exactos.
+#
+# Uso: 22_validate_no_app_name_leftover.sh <NEW_ENV>
+#
+# Termina con exactamente uno de estos mensajes:
+#   "APP_NAME_LEFTOVER_OK: sin referencias a '<APP_SOURCE>'"   (exit 0)
+#   "APP_NAME_LEFTOVER_FOUND: <n> archivo(s) (ver detalle arriba)"  (exit 1)
+
+set -uo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+# shellcheck source=lib/common.sh
+source "$SCRIPT_DIR/lib/common.sh"
+
+NEW_ENV="${1:-}"
+[[ -n "$NEW_ENV" ]] || ksc_die "uso: 22_validate_no_app_name_leftover.sh <NEW_ENV>"
+
+REPO_ROOT="$(ksc_repo_root)"
+NEW_DIR="$REPO_ROOT/live/$NEW_ENV"
+[[ -d "$NEW_DIR" ]] || ksc_die "no existe $NEW_DIR"
+
+CONFIG_FILE="$(ksc_config_path "$REPO_ROOT" "$NEW_ENV")"
+SOURCE_ENV=""
+[[ -f "$CONFIG_FILE" ]] && SOURCE_ENV="$(ksc_hcl_get "$CONFIG_FILE" SOURCE_ENV 2>/dev/null || true)"
+[[ -n "$SOURCE_ENV" ]] || SOURCE_ENV="$(grep -m1 '^SOURCE_ENV=' "$CONFIG_FILE" 2>/dev/null | sed -E 's/^SOURCE_ENV="(.*)"$/\1/')"
+[[ -n "$SOURCE_ENV" ]] || ksc_die "no pude determinar SOURCE_ENV (no está en $CONFIG_FILE) — no se puede validar sin saber qué nombre de app buscar"
+
+read -r APP_SOURCE _ < <(ksc_split_env "$SOURCE_ENV")
+
+FAILURES=()
+
+# Mismo criterio que 21 (comentarios excluidos: la NOTA de project_iam
+# menciona SOURCE_ENV completo a propósito, lo que incluye APP_SOURCE
+# como substring) y misma cobertura de archivos (find, no una lista fija
+# de nombres — Review V2, N-3).
+while IFS= read -r -d '' file; do
+  hit="$(grep -v '^[[:space:]]*#' "$file" 2>/dev/null | grep -i -m1 -- "$APP_SOURCE" | sed -E 's/^[[:space:]]+//')"
+  if [[ -n "$hit" ]]; then
+    FAILURES+=("$file: \"$hit\"")
+  fi
+done < <(find "$NEW_DIR" -maxdepth 2 -type f -print0)
+
+if [[ "${#FAILURES[@]}" -eq 0 ]]; then
+  echo "APP_NAME_LEFTOVER_OK: sin referencias a '$APP_SOURCE' (ninguna capitalización) en $NEW_DIR"
+  exit 0
+fi
+
+echo "Encontrado el nombre de la app fuente ('$APP_SOURCE', cualquier capitalización) fuera de comentarios:"
+printf '  - %s\n' "${FAILURES[@]}"
+echo "APP_NAME_LEFTOVER_FOUND: ${#FAILURES[@]} archivo(s) (ver detalle arriba) — corrige el shell script que genera ese componente para que sustituya '$APP_SOURCE' por el nombre de la app nueva, en cualquier capitalización (ver ksc_substr_replace_app en lib/common.sh)."
+exit 1

package/skill/scripts/lib/common.sh

@@ -745,3 +745,44 @@ ksc_substr_replace() {
   local file="$1" old="$2" new="$3"
   sed -i "s/${old}/${new}/g" "$file"
 }
+
+# ksc_substr_replace_app <file> <app_source_lower> <app_new_lower>
+#
+# Reemplaza TODAS las variantes de capitalización del nombre corto de la
+# app fuente (no solo minúscula exacta ni "Primera-mayúscula" exacta) por
+# la variante equivalente del nombre nuevo. Caso real encontrado
+# construyendo `coreservices-qa` desde `xoloshop-qa`: `service_accounts`
+# usa el nombre de marca estilizado `"XoloShop"` (con S interna
+# mayúscula) en `display_name`/`description` — ni
+# `ksc_substr_replace "$APP_SOURCE"` (minúscula exacta) ni
+# `ksc_substr_replace "$(ksc_capitalize "$APP_SOURCE")"` ("Xoloshop",
+# solo la primera letra) hacen match contra "XoloShop", así que ese
+# leftover pasaba completo a `coreservices-qa` en silencio. Resuelto
+# haciendo el match insensible a mayúsculas/minúsculas y eligiendo la
+# capitalización del REEMPLAZO según cómo estaba escrita la coincidencia
+# encontrada (todo minúsculas -> nuevo en minúsculas; todo mayúsculas ->
+# nuevo en mayúsculas; cualquier otra mezcla, incluidos estilos de marca
+# como "XoloShop" -> primera letra mayúscula del nuevo, mejor esfuerzo).
+ksc_substr_replace_app() {
+  local file="$1" app_source="$2" app_new="$3"
+  [[ -f "$file" ]] || return 0
+  python3 - "$file" "$app_source" "$app_new" <<'PYEOF'
+import re, sys
+file, app_source, app_new = sys.argv[1], sys.argv[2], sys.argv[3]
+with open(file) as f:
+    text = f.read()
+pattern = re.compile(re.escape(app_source), re.IGNORECASE)
+
+def repl(m):
+    s = m.group(0)
+    if s.isupper() and len(s) > 1:
+        return app_new.upper()
+    if s.islower():
+        return app_new.lower()
+    return app_new[:1].upper() + app_new[1:].lower()
+
+new_text = pattern.sub(repl, text)
+with open(file, "w") as f:
+    f.write(new_text)
+PYEOF
+}

package/skill/scripts/run_tracking.sh

@@ -10,7 +10,19 @@
 #   run_tracking.sh step-done   <config_file> "<nombre del paso>"
 #   run_tracking.sh step-error  <config_file> "<nombre del paso>" "<detalle>"
 #   run_tracking.sh status      <config_file>
-#   run_tracking.sh finalize    <config_file>
+#   run_tracking.sh finalize    <config_file> [archivo_de_resumen]
+#
+# `init-plan` manda siempre --process-name "/kcreate-scaffolding-gcp-script"
+# y --process-inputs con SOURCE_ENV/NEW_ENV (requiere github-proyect-tracking
+# >= 0.5.0/0.6.0 — ver vendor/VENDORED_FROM.md) — así el Issue de tracking
+# dice de entrada QUÉ skill lo está usando y CON QUÉ parámetros, sin que el
+# humano tenga que adivinarlo leyendo los comentarios de los pasos.
+#
+# `finalize` acepta opcionalmente la ruta a un archivo de texto con el
+# resumen final de la ejecución (requiere github-proyect-tracking >= 0.7.0):
+# si se da, ese resumen queda como un comentario APARTE en el Issue,
+# después del de FINALIZADO y antes de cerrarlo — el mismo resumen que el
+# agente ya le muestra al humano en pantalla, también en el Issue.
 #
 # Si github-proyect-tracking no está instalado junto a este skill, todos los
 # subcomandos salen con error claro (código 3) en vez de fallar a medias.
@@ -42,7 +54,10 @@ case "$SUBCOMMAND" in
   init-plan)
     PLAN_FILE="${3:-}"
     [[ -n "$PLAN_FILE" && -f "$PLAN_FILE" ]] || ksc_die "init-plan requiere un archivo plan.json existente"
-    TP init --plan-file "$PLAN_FILE"
+    PROCESS_INPUTS="$(python3 -c 'import json,sys; print(json.dumps({"SOURCE_ENV": sys.argv[1], "NEW_ENV": sys.argv[2]}))' "$SOURCE_ENV" "$NEW_ENV")"
+    TP init --plan-file "$PLAN_FILE" \
+      --process-name "/kcreate-scaffolding-gcp-script" \
+      --process-inputs "$PROCESS_INPUTS"
     ;;
   resume)
     TP resume
@@ -64,7 +79,13 @@ case "$SUBCOMMAND" in
     TP status --remote
     ;;
   finalize)
-    TP finalize
+    SUMMARY_FILE="${3:-}"
+    if [[ -n "$SUMMARY_FILE" ]]; then
+      [[ -f "$SUMMARY_FILE" ]] || ksc_die "no existe el archivo de resumen: $SUMMARY_FILE"
+      TP finalize --summary-file "$SUMMARY_FILE"
+    else
+      TP finalize
+    fi
     ;;
   *)
     ksc_die "subcomando desconocido: $SUBCOMMAND"

package/vendor/github-proyect-tracking/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: github-proyect-tracking
 description: Track process execution state in GitHub Issues with resume.
-version: 0.4.0
+version: 0.7.0
 author: Rommel (rommelmg), Hermes Agent
 license: MIT
 platforms: [linux, macos, windows]
@@ -69,7 +69,7 @@ python3 "$SKILL" doctor --url https://github.com/OWNER/REPO --token "$GITHUB_TOK
 
 | Comando | Efecto |
 |---|---|
-| `init --url URL [--plan JSON] [--store-token]` | Valida URL+token, crea el Issue, guarda `active_process_id` |
+| `init --url URL [--plan JSON] [--store-token] [--process-name N]` | Valida URL+token, crea el Issue (título `[Process Tracking][N] Execution ID: …` si se da N), guarda `active_process_id` y `process_name` |
 | `resume [--url URL]` | Lee el ÚLTIMO comentario y dicta cómo continuar |
 | `step-start --name N` | Comenta `[STATUS: INICIANDO] - Paso: N` (valida orden del plan) |
 | `step-done --name N` | Comenta `[STATUS: COMPLETADO] - Paso: N` (exige paso en vuelo) |
@@ -95,9 +95,18 @@ exit 0) y `KeyboardInterrupt` (130).
    lectura hace fallar `issues-write`; `UNVERIFIED` se reserva para permisos
    granulares que la API no puede confirmar.
 2. **Init.** `init --url URL --plan '["Paso 1: ...", ...]'` (plan
-   recomendado: nombres ÚNICOS; hace la reanudación determinista). Si
-   devuelve `RESUME_REQUIRED` (exit 7), NO crees otro Issue: ve al paso 3.
-   Criterio: `execution_id` e `issue_url` en la salida.
+   recomendado: nombres ÚNICOS; hace la reanudación determinista).
+   Si el proceso pertenece a un skill padre, añade
+   `--process-name "Mi Skill"`: el título del Issue pasa a
+   `[Process Tracking][Mi Skill] Execution ID: …` y el cuerpo incluye
+   `- **Proceso:** Mi Skill` — así el Issue identifica QUÉ se rastrea.
+   Para dejar constancia de CON QUÉ se ejecutó, añade `--process-inputs
+   '{"archivo":"x.csv","modo":"lint"}'` (objeto clave→valor; se publica
+   en la sección "Parámetros de entrada" del Issue, con secretos
+   redactados).
+   Si devuelve `RESUME_REQUIRED` (exit 7), NO crees otro Issue: ve al
+   paso 3. Criterio: `execution_id`, `process_name` e `issue_url` en la
+   salida.
 3. **Reanudar (si aplica).** `resume` y sigue el `verdict.action`
    (`RERUN_STEP`, `NEXT_STEP`, `START_FIRST`, `ALL_STEPS_DONE`/
    `FINISH_CLEANUP` → finalize, `ABORTED_EXTERNALLY` → pregunta al

package/vendor/github-proyect-tracking/references/api.md

@@ -42,7 +42,7 @@ texto y los usa para reconciliar únicamente el intento que originó el POST.
 
 ## Comandos
 
-### `init --url URL [--plan JSON | --plan-file F] [--token T] [--prompt-token] [--store-token]`
+### `init --url URL [--plan JSON | --plan-file F] [--token T] [--prompt-token] [--store-token] [--process-name N] [--process-inputs JSON]`
 
 - Valida la URL (regex, redactada en errores), resuelve el token, valida
   `issues:write` ANTES de crear nada.
@@ -54,6 +54,20 @@ texto y los usa para reconciliar únicamente el intento que originó el POST.
   `resume` determinista.
 - `--store-token`: persistencia del token OPT-IN (por defecto NO se
   guarda; `--no-store-token` quedó obsoleto).
+- `--process-name N`: nombre del proceso/skill padre. Título resultante:
+  `[Process Tracking][N] Execution ID: {exec_id}`; el cuerpo incluye
+  `- **Proceso:** N`; estado y JSON llevan `process_name`. Sin `N`, se
+  conserva el formato legado `[Process Tracking] Execution ID: …`.
+  Un secreto en `N` se redacta; `[`/`]`/saltos → `VALIDATION_ERROR`.
+- `--process-inputs JSON`: objeto clave→valor con los parámetros de
+  entrada del proceso. Se publican en la sección "Parámetros de entrada"
+  del cuerpo del Issue (ordenados por clave, valores entre backticks) y
+  se guardan en el estado (`process_inputs`) y en la salida de `init`
+  (`process_inputs`). Secretos en claves/valores se REDACTAN; límites:
+  50 pares, valores ≤ 2000 caracteres; claves vacías, JSON inválido o no
+  objeto → `VALIDATION_ERROR`. Sin la opción, el estado queda limpio
+  (`process_inputs: null`) y el cuerpo no tiene la sección.
+- Salida de `init`: añade `process_name`, `process_inputs` e `issue_title`.
 
 Salida: `execution_id`, `issue_number`, `issue_url`, `state_file`, `plan`,
 `first_step`, `token_source`.
@@ -87,7 +101,7 @@ Publica `[STATUS: ERROR] - Paso: {N} - Detalles: {D}` y fija
 reanudar exige `resume`). `--details-file` ideal para stacktraces largos
 (trunca a 60000 chars).
 
-### `finalize [--url URL] [--token T] [--force]`
+### `finalize [--url URL] [--token T] [--force] [--summary TEXT | --summary-file F]`
 
 1. Verifica el veredicto remoto: rechaza procesos con pasos pendientes
    (`FINALIZE_BLOCKED`, exit 8) y abortes externos. Sin plan permite éxito
@@ -96,10 +110,18 @@ reanudar exige `resume`). `--details-file` ideal para stacktraces largos
    exitosamente.` (idempotente). Con `--force`: `[STATUS: CANCELADO] -
    El proceso fue cerrado anticipadamente (--force).` con los pasos
    pendientes (cierre anticipado distinguible, nunca éxito falso).
-3. Cierra el Issue (PATCH state=closed) y **verifica re-leyendo**.
-4. Limpia `active_process_id` (estado `FINALIZED`/`CANCELADO`) + historial
+3. Si se dio `--summary`/`--summary-file` **y** la ruta es de éxito (no
+   `--force`): publica un comentario APARTE con ese texto (sanitizado y
+   truncado a 60000 chars, igual que `--details`), inmediatamente después
+   del de FINALIZADO. Sin marcador `[STATUS: ...]`, así que `COMMENT_RE`
+   lo ignora en lecturas futuras — no es parte de la máquina de estados,
+   solo queda como constancia legible en el Issue. `--summary`/
+   `--summary-file` vacío o en blanco no publica nada.
+4. Cierra el Issue (PATCH state=closed) y **verifica re-leyendo**.
+5. Limpia `active_process_id` (estado `FINALIZED`/`CANCELADO`) + historial
    (con `outcome`). Un CANCELADO existente conserva ese resultado aunque el
-   reintento no lleve `--force`.
+   reintento no lleve `--force`. La salida incluye
+   `summary_comment_posted`/`summary_comment_url`.
 
 ### `status [--url URL] [--remote]`
 

package/vendor/github-proyect-tracking/scripts/tracking.py

@@ -95,9 +95,17 @@ def build_parser():
         "init", help="nueva ejecución: valida, crea el Issue y guarda memoria")
     common(subparser, url_required=True)
     subparser.add_argument("--plan", default=None, metavar="JSON",
-                           help='plan de pasos con nombres ÚNICOS, ej. \'["Paso 1","Paso 2"]\'')
+                           help='plan de pasos con nombres ÚNICOS, ej. \'["Paso 1", "Paso 2"]\'')
     subparser.add_argument("--plan-file", default=None, metavar="F",
                            help="archivo JSON con la lista de pasos")
+    subparser.add_argument("--process-name", default=None, metavar="N",
+                           help="nombre del proceso/skill padre que se rastrea "
+                                "(aparece en el título y cuerpo del Issue)")
+    subparser.add_argument("--process-inputs", default=None, metavar="JSON",
+                           help='parámetros de entrada del proceso (objeto '
+                                "clave→valor, se publican en el Issue; los "
+                                "secretos se redactan), ej. \'{\"archivo\": "
+                                '\"datos.csv\"}\'')
     subparser.add_argument("--prompt-token", action="store_true",
                            help="pedir el token interactivamente (TTY)")
     subparser.add_argument("--store-token", action="store_true",
@@ -139,6 +147,13 @@ def build_parser():
     subparser.add_argument("--force", action="store_true",
                            help="cancelar aunque queden pasos pendientes o no haya trabajo "
                                 "(no aplica si el Issue fue cerrado externamente)")
+    subparser.add_argument("--summary", default=None, metavar="TEXT",
+                           help="resumen final del proceso (se publica como comentario "
+                                "aparte, después del de FINALIZADO y antes de cerrar el "
+                                "Issue; se sanitiza igual que --details). Solo aplica en "
+                                "la ruta de éxito (no con --force)")
+    subparser.add_argument("--summary-file", default=None, metavar="F",
+                           help="archivo con el resumen final (alternativa a --summary)")
     subparser.set_defaults(func=cmd_finalize)
 
     subparser = subparsers.add_parser(
@@ -153,6 +168,9 @@ def build_parser():
     common(subparser, url_required=True)
     subparser.add_argument("--execution-id", required=True, metavar="ID",
                            help="Execution ID EXACTO del título del Issue")
+    subparser.add_argument("--process-name", default=None, metavar="N",
+                           help="nombre del proceso a adoptar (filtro adicional "
+                                "opcional si hay ambigüedad)")
     subparser.add_argument("--force", action="store_true",
                            help="reemplazar un proceso activo existente (conserva token "
                                 "e historial)")

package/vendor/github-proyect-tracking/scripts/tracking_core/commands.py

@@ -14,8 +14,9 @@ from .common import (
     EXIT_RESUME_REQUIRED, EXIT_RUNTIME, EXIT_TOKEN_INSUFFICIENT,
     EXIT_VALIDATION, MAX_DETAILS_LEN, MAX_PLAN_STEPS, SCHEMA_VERSION,
     STATUS_CANCELADO, STATUS_COMPLETADO, STATUS_ERROR, STATUS_FINALIZADO,
-    STATUS_INICIANDO, SkillError, emit, new_execution_id, normalize_step_name,
-    now_iso, ordered_unique, redact_url, sanitize_text, validate_repo_url,
+    STATUS_INICIANDO, TITLE_RE, SkillError, emit, new_execution_id,
+    normalize_process_name, normalize_step_name, now_iso, ordered_unique,
+    issue_title, redact_url, sanitize_text, validate_repo_url,
 )
 from .events import (
     build_issue_body, events_from_comments, fmt_cancelado, fmt_completado,
@@ -96,6 +97,47 @@ def load_plan(args):
     return plan
 
 
+MAX_INPUTS_COUNT = 50
+MAX_INPUT_VALUE_LEN = 2000
+
+
+def load_process_inputs(args):
+    """Valida y normaliza --process-inputs (objeto JSON clave→valor).
+
+    - claves y valores se convierten a cadena; claves vacías se rechazan
+    - secretos en valores (y claves) se REDACTAN antes de guardar/publicar
+    - valores se truncan a MAX_INPUT_VALUE_LEN; máx MAX_INPUTS_COUNT pares
+    - devuelve None cuando no se pasó la opción (mantiene el estado limpio)
+    """
+    raw = getattr(args, "process_inputs", None)
+    if raw is None:
+        return None
+    try:
+        data = json.loads(raw)
+    except json.JSONDecodeError as error:
+        raise SkillError(EXIT_VALIDATION, "VALIDATION_ERROR",
+                         f"--process-inputs no es JSON válido: {error}")
+    if not isinstance(data, dict):
+        raise SkillError(EXIT_VALIDATION, "VALIDATION_ERROR",
+                         "--process-inputs debe ser un objeto JSON "
+                         "clave→valor, ej. '{\"archivo\": \"x.csv\", "
+                         "\"modo\": \"lint\"}'")
+    if len(data) > MAX_INPUTS_COUNT:
+        raise SkillError(EXIT_VALIDATION, "VALIDATION_ERROR",
+                         f"--process-inputs no puede exceder "
+                         f"{MAX_INPUTS_COUNT} pares")
+    inputs = {}
+    for key, value in data.items():
+        clean_key, _ = sanitize_text(str(key).strip())
+        clean_key = clean_key.strip()
+        if not clean_key:
+            raise SkillError(EXIT_VALIDATION, "VALIDATION_ERROR",
+                             "--process-inputs: las claves no pueden ser vacías")
+        clean_value, _ = sanitize_text(str(value))
+        inputs[clean_key] = clean_value[:MAX_INPUT_VALUE_LEN]
+    return inputs or None
+
+
 def _remote_snapshot(owner, repo, number, token):
     issue = github.fetch_issue(owner, repo, number, token)
     comments = github.fetch_all_comments(owner, repo, number, token)
@@ -125,6 +167,8 @@ def cmd_init(args):
     owner, repo = target
     path = state_file_for(owner, repo)
     plan = load_plan(args)
+    process_name = normalize_process_name(getattr(args, "process_name", None))
+    process_inputs = load_process_inputs(args)
 
     lock = StateLock(path)
     with lock:
@@ -154,8 +198,10 @@ def cmd_init(args):
         store = bool(args.store_token) and source in ("cli", "prompt")
 
         execution_id = new_execution_id()
-        title = f"[Process Tracking] Execution ID: {execution_id}"
-        body = build_issue_body(args.url.strip(), execution_id, plan)
+        title = issue_title(execution_id, process_name)
+        body = build_issue_body(args.url.strip(), execution_id, plan,
+                                process_name=process_name,
+                                process_inputs=process_inputs)
         recovered = False
         create_error = None
         lock.ensure_owner()
@@ -202,6 +248,8 @@ def cmd_init(args):
             "owner": owner, "repo": repo,
             "active_process_id": number,
             "execution_id": execution_id,
+            "process_name": process_name,
+            "process_inputs": process_inputs or None,
             "issue_url": data.get("html_url"),
             "process_state": "RUNNING",
             "current_step": None,
@@ -224,6 +272,8 @@ def cmd_init(args):
             "ok": True, "action": "INIT",
             "execution_id": execution_id, "issue_number": number,
             "issue_url": data.get("html_url"), "state_file": str(path),
+            "process_name": process_name, "issue_title": title,
+            "process_inputs": process_inputs or None,
             "plan": plan, "first_step": plan[0] if plan else None,
             "recovered": recovered,
             "token_source": source, "token_stored": bool(state["github_token"]),
@@ -493,6 +543,25 @@ _PENDING_VERDICTS = ("RERUN_STEP", "NEXT_STEP", "START_FIRST",
 
 
 def cmd_finalize(args):
+    summary = getattr(args, "summary", None)
+    summary_file = getattr(args, "summary_file", None)
+    if summary and summary_file:
+        raise SkillError(EXIT_VALIDATION, "VALIDATION_ERROR",
+                         "usa --summary o --summary-file, no ambos")
+    if summary_file:
+        try:
+            summary = Path(summary_file).read_text(encoding="utf-8", errors="replace")
+        except OSError as error:
+            raise SkillError(EXIT_VALIDATION, "VALIDATION_ERROR",
+                             f"no se pudo leer --summary-file: {error}")
+    if summary is not None:
+        summary = summary.strip()
+        if summary:
+            summary, _ = sanitize_text(summary)
+            summary = summary[:MAX_DETAILS_LEN]
+        else:
+            summary = None
+
     owner, repo, path = resolve_target(args)
     lock = StateLock(path)
     with lock:
@@ -547,6 +616,19 @@ def cmd_finalize(args):
                 owner, repo, number, fmt_finalizado(), token,
                 baseline_ids=frozenset(item.get("id") for item in comments),
                 execution_id=state.get("execution_id"), sequence=len(events) + 1)
+
+        summary_comment = None
+        if summary and not forced and not already_cancel:
+            # Comentario aparte del resumen final, SOLO en la ruta de éxito
+            # (no al cancelar): va después del de FINALIZADO y antes de
+            # cerrar el Issue. No lleva el marcador [STATUS: ...], así que
+            # COMMENT_RE lo ignora en futuras lecturas de eventos — no
+            # interfiere con resume/plan_resume.
+            summary_comment = github.post_comment(
+                owner, repo, number, summary, token,
+                baseline_ids=frozenset(item.get("id") for item in comments),
+                execution_id=state.get("execution_id"), sequence=len(events) + 2)
+
         github.close_issue(owner, repo, number, token)
         issue = github.fetch_issue(owner, repo, number, token)
         if issue.get("state") != "closed":
@@ -586,6 +668,8 @@ def cmd_finalize(args):
             "forced": outcome == "CANCELADO",
             "comment_posted": bool(comment),
             "comment_url": comment["comment_url"] if comment else None,
+            "summary_comment_posted": bool(summary_comment),
+            "summary_comment_url": summary_comment["comment_url"] if summary_comment else None,
             "completed_steps": completed,
             "active_process_id": None,
             "state_file": str(path),
@@ -653,8 +737,9 @@ def cmd_adopt(args):
     existing = load_state(path)
     token, _ = need_token(args, existing)
 
-    query = (f'repo:{owner}/{repo} "[Process Tracking] Execution ID: {execution_id}" '
-             f'in:title is:issue')
+    # v0.5.0: el título puede incluir [Nombre]; se busca por el execution_id
+    # (único) y el filtrado canónico exacto lo hace canonical_title_match.
+    query = f'repo:{owner}/{repo} "{execution_id}" in:title is:issue'
     status, data, _ = github.api(
         "GET", "/search/issues?" + urllib.parse.urlencode({"q": query, "per_page": 30}),
         token)
@@ -662,8 +747,10 @@ def cmd_adopt(args):
         raise SkillError(EXIT_RUNTIME, "SEARCH_FAILED",
                          f"búsqueda de Issues devolvió {status}: "
                          f"{data.get('message', '')}")
+    process_name = normalize_process_name(getattr(args, "process_name", None))
     matches = [issue for issue in (data.get("items") or [])
-               if github.canonical_title_match(issue, execution_id)]
+               if github.canonical_title_match(issue, execution_id,
+                                               process_name=process_name)]
     if not matches:
         raise SkillError(EXIT_NOT_FOUND, "ISSUE_NOT_FOUND",
                          f"no se encontró un Issue con título canónico para "
@@ -691,6 +778,10 @@ def cmd_adopt(args):
         plan = parse_plan_from_body(issue.get("body") or "")
         verdict = plan_resume(events, plan, issue.get("state", "open"))
         action = verdict["action"]
+        title_match = TITLE_RE.match((issue.get("title") or "").strip())
+        adopted_name = (title_match.group("process_name")
+                        if title_match and title_match.group("process_name")
+                        else None)
         if issue.get("state") == "open":
             active = number
             process_state = ("ERROR" if events and events[-1]["status"] == STATUS_ERROR
@@ -708,6 +799,7 @@ def cmd_adopt(args):
             "owner": owner, "repo": repo,
             "active_process_id": active,
             "execution_id": execution_id,
+            "process_name": process_name or adopted_name,
             "issue_url": issue.get("html_url"),
             "process_state": process_state,
             "current_step": verdict.get("resume_from_step"),
@@ -727,7 +819,9 @@ def cmd_adopt(args):
             "ok": True, "action": "ADOPT", "execution_id": execution_id,
             "issue_number": number, "issue_url": issue.get("html_url"),
             "issue_state": issue.get("state"), "verdict": verdict,
-            "process_state": process_state, "state_file": str(path),
+            "process_state": process_state,
+            "process_name": process_name or adopted_name,
+            "state_file": str(path),
         })
     return EXIT_OK
 

package/vendor/github-proyect-tracking/scripts/tracking_core/common.py

@@ -7,7 +7,7 @@ import re
 import uuid
 from datetime import datetime, timezone
 
-VERSION = "0.4.0"
+VERSION = "0.6.0"
 API_BASE = "https://api.github.com"
 USER_AGENT = f"github-proyect-tracking/{VERSION}"
 
@@ -47,10 +47,18 @@ REPO_URL_RE = re.compile(
     r"(?P<repo>[A-Za-z0-9._-]+?)(?:\.git)?/?$",
     re.IGNORECASE,
 )
+# Título dual (v0.5.0): con o sin nombre de proceso.
+#   [Process Tracking][Mi Skill] Execution ID: exec-...
+#   [Process Tracking] Execution ID: exec-...           (formato <=0.4.x)
 TITLE_RE = re.compile(
-    r"^\[Process Tracking\]\s*(?:-\s*)?Execution ID:\s*(?P<exec_id>\S+?)\s*$",
+    r"^\[Process Tracking\]"
+    r"(?:\[(?P<process_name>"
+    r"(?:[^\[\]\r\n]|\[RED[Aa]ctado:[^\[\]]*\]){1,200}"
+    r")\])?"
+    r"\s*(?:-\s*)?Execution ID:\s*(?P<exec_id>\S+?)\s*$",
     re.IGNORECASE,
 )
+MAX_PROCESS_NAME_LEN = 100
 
 SECRET_REDACTIONS = [
     (re.compile(r"(?i)\b(authorization|proxy-authorization)\s*[:=]\s*"
@@ -68,6 +76,43 @@ SECRET_REDACTIONS = [
 ]
 
 
+def normalize_process_name(name):
+    """Normaliza el nombre del proceso (skill padre) para título y cuerpo
+    del Issue. Orden V2-aprendido: validar la entrada CRUDA (longitud y
+    corchetes) ANTES de sanitizar — los marcadores [REDactado:...] que
+    introduce la sanitización son legítimos y TITLE_RE los acepta."""
+    if name is None:
+        return None
+    text = str(name).strip()
+    if not text:
+        return None
+    if len(text) > MAX_PROCESS_NAME_LEN:
+        raise SkillError(
+            EXIT_VALIDATION, "VALIDATION_ERROR",
+            f"el nombre del proceso no puede exceder {MAX_PROCESS_NAME_LEN} "
+            f"caracteres (recibido: {len(text)})")
+    if any(ch in text for ch in "[]\r\n"):
+        raise SkillError(EXIT_VALIDATION, "VALIDATION_ERROR",
+                         "el nombre del proceso no puede contener '[', ']' "
+                         "ni saltos de línea (rompe el título canónico)")
+    clean, _ = sanitize_text(text)
+    clean = clean.strip()
+    if not clean:
+        raise SkillError(EXIT_VALIDATION, "VALIDATION_ERROR",
+                         "el nombre del proceso quedó vacío tras sanitizar")
+    return clean
+
+
+def issue_title(execution_id, process_name=None):
+    """Título canónico del Issue con el nombre del proceso (v0.5.0).
+    El nombre debe venir YA normalizado (normalize_process_name); aquí no
+    se re-valida porque los marcadores [REDactado:...] son legítimos."""
+    if process_name:
+        return f"[Process Tracking][{process_name}] Execution ID: {execution_id}"
+    return f"[Process Tracking] Execution ID: {execution_id}"
+
+
+
 class SkillError(Exception):
     """Error operativo que se serializa como un único objeto JSON."""
 

package/vendor/github-proyect-tracking/scripts/tracking_core/events.py

@@ -98,13 +98,42 @@ def events_from_comments(comments):
     return events
 
 
-def build_issue_body(url, execution_id, plan):
+def _normalized_inputs(process_inputs):
+    """Normaliza los parámetros de entrada a pares (clave, valor) ordenados,
+    con ambos convertidos a cadena. Devuelve [] si no hay inputs."""
+    if not process_inputs:
+        return []
+    if not isinstance(process_inputs, dict):
+        return []
+    entries = []
+    for key in sorted(process_inputs, key=str):
+        value = process_inputs[key]
+        entries.append((str(key).strip(), str(value)))
+    return [(k, v) for k, v in entries if k]
+
+
+def build_issue_body(url, execution_id, plan, process_name=None,
+                     process_inputs=None):
     lines = [
         "Proceso rastreado por el skill `github-proyect-tracking`.",
         "",
         f"- **Execution ID:** `{execution_id}`",
+    ]
+    if process_name:
+        lines.append(f"- **Proceso:** {process_name}")
+    lines += [
         f"- **Proyecto:** {url}",
         f"- **Iniciado (UTC):** {now_iso()}",
+    ]
+
+    # v0.6.0: parámetros de entrada del proceso — la única forma de saber
+    # exactamente qué tarea estaba realizando esta ejecución.
+    entries = _normalized_inputs(process_inputs)
+    if entries:
+        lines += ["", "## Parámetros de entrada", ""]
+        lines += [f"- **{key}:** `{value}`" for key, value in entries]
+
+    lines += [
         "",
         "## Plan de pasos",
     ]

package/vendor/github-proyect-tracking/scripts/tracking_core/github.py

@@ -14,7 +14,7 @@ import uuid
 from .common import (
     AMBIGUOUS_HTTP_STATUSES, API_BASE, EXIT_NOT_FOUND, EXIT_NO_TOKEN,
     EXIT_RUNTIME, EXIT_TOKEN_INSUFFICIENT, MAX_COMMENT_PAGES, TITLE_RE,
-    USER_AGENT, SkillError,
+    USER_AGENT, SkillError, issue_title,
 )
 from .events import events_from_comments, transition_metadata, with_transition_metadata
 
@@ -295,6 +295,7 @@ def close_issue(owner, repo, number, token):
 
 
 def find_issue_by_title(owner, repo, title, token):
+    # v0.5.0: title ya viene construido con issue_title()
     url = (f"{API_BASE}/repos/{owner}/{repo}/issues?state=all&sort=created"
            "&direction=desc&per_page=100")
     seen = set()
@@ -310,6 +311,14 @@ def find_issue_by_title(owner, repo, title, token):
     return None
 
 
-def canonical_title_match(issue, execution_id):
+def canonical_title_match(issue, execution_id, process_name=None):
+    """v0.5.0: casa el título canónico con o sin nombre de proceso; el
+    exec_id debe coincidir EXACTO y, si se indica process_name, también."""
     match = TITLE_RE.match((issue.get("title") or "").strip())
-    return bool(match and match.group("exec_id").lower() == execution_id.lower())
+    if not match or match.group("exec_id").lower() != execution_id.lower():
+        return False
+    if process_name:
+        found = match.group("process_name")
+        if (found or "").strip().lower() != str(process_name).strip().lower():
+            return False
+    return True