navori 0.2.20 → 0.2.22

package/README.md

@@ -47,7 +47,8 @@ Y genera:
 | `add <plugin>` | Activa un plugin y opcionalmente instala la tool externa |
 | `configure <section>` | Ajusta una sección del config sin re-correr el wizard |
 | `update` | Re-detecta el repo, refresca config y corre sync en un paso |
-| `render` | Genera CLAUDE.md y `.claude/` desde el config (preview por default; `--apply` escribe) |
+| `render` | Genera CLAUDE.md y `.claude/` desde el config (preview por default; `--apply` escribe). `--all` renderea todos los repos del registro global; `--prune` limpia los que ya no existen |
+| `registry <sub>` | Registro global de tus repos con navori, para `render --all` (`ls`, `scan <dir>`, `add`, `remove`, `prune`) |
 | `sync` | Refresca los managed blocks con conflict resolution + backups |
 | `preset init <id>` | Scaffoldea un preset local en `.navori/presets/<id>/` |
 | `scan` | Detecta workspaces nuevos en monorepos (`pnpm-workspace.yaml` / `package.json#workspaces`) |
@@ -161,6 +162,36 @@ navori workspace render bonum --apply    # escribe en cada repo
 
 Storage: `~/.navori/workspaces/<name>/` (manifest + tickets/ + backups/).
 
+## Rollout global tras un bump de navori
+
+Cuando actualizas el CLI (`npm i -g navori@latest`), el registro global mete los
+cambios a **todos** tus repos en un comando — sin ir uno por uno:
+
+```bash
+navori render --all            # preview: qué cambiaría en cada repo del registro
+navori render --all --apply     # escribe el render nuevo en todos
+navori render --all --verbose   # además lista cada bloque managed que cambió, por repo
+navori render --all --prune     # además limpia repos que ya no existen
+```
+
+El output es un registro autoexplicativo: header con el registro y el modo
+(preview/apply), una línea por repo (`created`/`updated`/`conflict`/`removed`/`unchanged`),
+un aviso que **nombra** los repos con bloques editados a mano (conflict, que el
+render no pisa) y un roll-up `ok · changed · conflict · failed`.
+
+El registro (`~/.navori/registry.json`) se puebla solo: cada `navori init` /
+`navori update` te da de alta. Para arrancar con lo que ya tenías instalado,
+escanéalo una vez:
+
+```bash
+navori registry scan ~/dev ~/otra-carpeta   # registra todo lo que tenga navori.config.json
+navori registry ls                          # ver el registro (✓ presente / ✗ missing)
+navori registry prune                       # quitar los que ya no existen
+```
+
+Es ortogonal a los workspaces: el registro es "qué repos existen"; el workspace
+es el perfil de policy (branchBase/prTarget) que cada repo hereda.
+
 ## Managed blocks con versionado
 
 Cada bloque que `navori` inyecta en tu `CLAUDE.md` lleva metadata:

package/dist/assets/core/core-assets/agents/commit-pr-pilot.md

@@ -38,9 +38,23 @@ git diff origin/{{prTarget}}...HEAD --stat            # scope REAL del PR (contr
 gh auth status                                        # gh autenticado
 ```
 
-Si el harness está activo, verifica que exista un review aprobado con la tool nativa `Grep` (read-only, no pide permiso): `pattern: "APPROVED"`, `path: ".claude/progress"`, `glob: "review_*.md"`, `output_mode: "files_with_matches"`.
+Si el harness está activo, identifica el review de ESTA feature: `.claude/progress/review_<feature>.md`, con `<feature>` el id que recibiste en tu brief. Un glob amplio (`review_*.md`) sobre todos los reviews no es válido — no alcanza con que exista algún review con `APPROVED` en el directorio, tiene que ser el de este feature.
 
-Sin `APPROVED` y con harness activo → abort, dile al usuario que falta review.
+Abre ese archivo puntual y confirma que su veredicto es `APPROVED` y que su sección de scope/feature nombra la misma feature que vas a commitear. Si el review lista los archivos que revisó, compáralos contra `git diff --name-only`: si hay archivos tocados que NO aparecen en esa lista, el review no cubre el cambio completo → NO cuenta como aprobado. Aborta, no crees el PR, y devuelve al reviewer para que cubra los archivos faltantes. No basta con mencionar la diferencia y seguir.
+
+<!-- Mantén esta regla de cobertura de archivos en sync con `skills/pr-create.md` (mismo chequeo, misma semántica de abort). -->
+
+
+Archivo ausente, ambiguo (más de un candidato) o con veredicto/scope que no matchea la feature actual → NO cuenta como aprobado: abort, dile al usuario que falta review y nunca asumas un `APPROVED` genérico.
+
+### Gate: no correr de más
+
+Tu `git commit`/`push` dispara los hooks `PreToolUse`, que corren **mecánicamente**: `quality-gate-pre-commit` (re-corre `{{qualityGate.fast}}` y bloquea si está en rojo) + jscpd/semgrep/cognitive (duplicación/seguridad/complejidad). Ese es el enforcement que no se puede saltar. Además, el `reviewer` ya corrió `{{qualityGate.fast}}` verde sobre este mismo diff (evidencia en `review_<feature>.md`, este ciclo) y tú **no editas código**.
+
+- ✅ **No corras `{{qualityGate.fast}}` a mano en el pre-flight.** Lo correrías dos veces sobre código ya verificado verde (tu corrida + el hook del commit). Confía en la evidencia del review para proceder; el hook del commit es el backstop mecánico.
+- ▶️ **Córrelo a mano antes de commitear** solo si dudas de que pase: el diff cambió desde el review, hubo rebase/merge, o no hay evidencia fresca del gate verde. Así evitas un commit bloqueado por el hook y el reintento.
+
+Nunca abras el PR con el gate en rojo.
 
 ## Flujo de commit (si hay cambios sin commitear)
 

package/dist/assets/core/core-assets/agents/implementer.md

@@ -48,6 +48,25 @@ Ejecutas **una sola** tarea desde inicio hasta verificación. No orquestas, no l
 - **JSDoc** obligatorio en exports públicos y funciones >15 líneas o con lógica condicional densa.
 - **Trazabilidad SDD** (solo si la feature tiene `{{sdd.specsDir}}/<feature>/tasks.md`, ver bloque SDD en `CLAUDE.md`): cada `R<n>` de tu lote queda cubierto por ≥1 test, y cada test referencia sus requisitos con un comentario `// Covers: R<n>` arriba del caso. Sin trazabilidad completa el `reviewer` rechaza.
 - Si una herramienta falla raro (ej. tsc rompe sin diff aparente), **no improvises workaround**: anota `Estado: BLOCKED` + el motivo en `.claude/progress/impl_<feature>.md` y paras.
+- **Mientras iteras, corre solo los tests del área que tocas** (filtro por path del runner). El gate completo del paso 4 corre al final, no en cada iteración — ahorra tiempo y contexto.
+- **Reporters silenciosos en corridas intermedias.** El output verboso infla tu contexto; deja el verbose solo para diagnosticar un fallo concreto.
+
+## Restraint (YAGNI)
+
+Antes de escribir código, recorre la escalera y para en el primer peldaño que aguante:
+
+1. **¿Necesita existir?** Necesidad especulativa → omítelo y dilo en una línea.
+2. **¿Lo cubre la stdlib** del lenguaje? Úsala.
+3. **¿Hay feature nativa de la plataforma?** (CSS sobre JS, `<input type="date">` sobre lib, constraint de DB sobre código de app).
+4. **¿Lo resuelve una dependencia ya instalada?** Úsala; no agregues una nueva por lo que unas líneas hacen.
+5. **¿Entra en una línea?** Una línea.
+6. **Solo entonces:** el mínimo código que funciona.
+
+Sin abstracciones especulativas: nada de interface / capa / flag con un solo caller "por si acaso". Gana el diff más corto; borrar antes que agregar. Marca cada atajo deliberado con un comentario que nombre su **techo** y su **disparador de upgrade** — ej. `// TODO(perf): lock global; shardear por cuenta si supera ~100 rps`. Un atajo sin disparador es deuda muda; el `reviewer` lo marca.
+
+**YAGNI ≠ código incompleto ni de menor calidad.** Aplica al *alcance especulativo* (construir para un futuro hipotético), NO a la *completitud del requisito actual*: los edge cases, estados de error y validaciones de lo que SÍ estás construyendo son parte del trabajo, no "código de más". La escalera elige la solución más simple que **cubre el caso**, nunca la que cubre menos casos. **Nunca** simplifiques (siempre va): validación de input en trust boundaries, manejo de errores que evita pérdida de datos, seguridad, accesibilidad, ni nada pedido explícitamente. La lógica no trivial deja al menos UN check ejecutable.
+
+**No deliberes de más.** Si el *alcance* es ambiguo entre mínimo y completo, entrega el mínimo razonable y cuestiónalo en la misma respuesta ("hice X; cubre Y. ¿Necesitas Z? dilo") en vez de gastar razonamiento sin escribir. Aplica al alcance, no a la calidad: la versión mínima igual va **completa** para lo que cubre.
 
 ## Evidence-based completion (gate antes del informe)
 

package/dist/assets/core/core-assets/agents/reviewer.md

@@ -28,7 +28,8 @@ Eres un revisor estricto. Tu única función es **aprobar o rechazar**. No edita
    git diff origin/{{prTarget}}...HEAD
    ```
 
-3. Aplica `.claude/skills/verify-before-done.md` antes de cualquier veredicto: corre los comandos de quality gate **en este turno** (no asumas del cache del informe del implementer).
+3. **Re-review** (si ya hay un `.claude/progress/review_<feature>.md` de un ciclo previo): enfoca la *lectura* en (a) que los issues listados ahí estén resueltos y (b) los archivos que el `implementer` reporta haber tocado en este ciclo (`impl_<feature>.md`). No re-revises desde cero el código ya aprobado que no cambió; el quality gate completo sí se corre igual — un cambio puede romper algo fuera del delta.
+4. Aplica `.claude/skills/verify-before-done.md` para todo `[x]` que dependa de evidencia. El quality gate se corre **en este turno, en la Pasada 2** (no antes: un `SPEC_MISS` en Pasada 1 no lo necesita — no gastes el gate en un diff que vas a rechazar por spec). No asumas del cache del informe del implementer.
 
 ### Pasada 1 — Spec compliance
 
@@ -50,7 +51,7 @@ Eres un revisor estricto. Tu única función es **aprobar o rechazar**. No edita
 
 ¿El código matchea las convenciones del repo? Aquí sí revisas estilo/naming/tipos.
 
-Aplica `.claude/skills/review-diff.md` — la checklist completa por dimensiones (tipos, capa de datos, errores, seguridad, hardcode, naming, dead code) con severidades. Sus CRÍTICO/ALTO mapean a los issues ≥80 de abajo; MEDIO a las observaciones informativas. Resumen de lo mínimo a validar contra `CLAUDE.md` y las "Reglas del proyecto" del leader:
+Aplica `.claude/skills/review-diff.md` — la checklist completa por dimensiones (tipos, capa de datos, errores, seguridad, hardcode, naming, sobre-ingeniería, dead code) con severidades. Sus CRÍTICO/ALTO mapean a los issues ≥80 de abajo; MEDIO a las observaciones informativas. Resumen de lo mínimo a validar contra `CLAUDE.md` y las "Reglas del proyecto" del leader:
 
 - **Convenciones**: naming, path aliases, estructura de carpetas.
 - **Tipos centralizados**: no `type`/`interface` inline donde la convención dice "afuera".
@@ -66,6 +67,8 @@ Aplica `.claude/skills/review-diff.md` — la checklist completa por dimensiones
 {{qualityGate.fast}}
 ```
 
+Léelo completo para verificar (exit code + conteo de failures), pero al informe deja solo `exit 0` + la línea de resumen (ej. `N passed`); en rojo, solo el tail que falla. No arrastres el log verboso completo turno a turno. Esta evidencia —gate verde sobre el diff final, en este ciclo— es la que el `commit-pr-pilot` reusa para **no** re-correr el gate, así que debe ser fresca y sobre el diff que se va a commitear.
+
 Si el informe del implementer dice "UI no validada" y el cambio toca pantallas, márcalo para verificación humana — no apruebes solo.
 
 **Veredicto parcial:**

package/dist/assets/core/core-assets/hooks/guard-destructive.sh

@@ -8,6 +8,14 @@
 # devices. Exit 2 in a PreToolUse hook is evaluated BEFORE permission rules, so
 # this is the strongest line of defense — it overrides even an `allow` match.
 #
+# KNOWN, ACCEPTED LIMITATION: matching is regex-based over the command string.
+# Multi-line continuations, git global options (`git -C … commit`), and simple
+# wrappers (`command`/`\git`/parens) ARE normalized before matching now, and a
+# quoted skip-flag (`git commit "--no-verify"`) is still caught. Still unhandled:
+# `sh -c`, `eval`, base64/printf obfuscation, and escaped-quote edge cases inside
+# quoted spans. This guard is a SEATBELT against accidental
+# destructive commands, NOT a sandbox against a deliberate adversary.
+#
 # The managed block below is regenerated by `navori render` and must NOT be
 # edited by hand. Add your repo-specific guards in the user section at the
 # bottom — `$cmd` is already parsed and in scope there.
@@ -42,17 +50,54 @@ block() {
   exit 2
 }
 
+# Normalized copies used ONLY by the hook-skip (1) and force-push (2) rules
+# below. `$cmd` stays intact for the messages and the other rules. The transforms
+# only add boundaries / drop noise, so they always push toward MORE blocking:
+#   FIX B — join `\<newline>` continuations into a space and flatten any other
+#           newline to `;` (a boundary the rules already handle) so a multi-line
+#           `git commit \<NL> --no-verify` is matched as one logical command.
+#   FIX C — neutralize wrappers into boundaries: a leading `command ` word, a
+#           leading backslash (`\git`), and `(` runs, so `command git …`,
+#           `\git …` and `(git …)` read as a plain `git …`.
+# `scan` keeps quoted spans intact, so a quoted skip-flag (`git commit
+# "--no-verify"`) is still caught — stripping the quotes there was a real bypass.
+# `scan_flags` additionally drops quoted spans and is used ONLY by the
+# combined-short-flag check, so a hyphen-word inside a commit message
+# (`-m "add -notify option"`) can't trip it.
+scan="$cmd"
+scan="${scan//\\$'\n'/ }"     # FIX B: join line continuations
+scan="${scan//$'\n'/;}"       # FIX B: flatten remaining newlines to a boundary
+scan=$(printf '%s' "$scan" | sed -E \
+  -e "s/(^|[;&|]|[[:space:]])command[[:space:]]+/\1/g" \
+  -e "s/\\\\([A-Za-z])/ \1/g" \
+  -e "s/\(/ /g")
+scan_flags=$(printf '%s' "$scan" | sed -E -e "s/'[^']*'//g" -e "s/\"[^\"]*\"//g")
+
+# Git commit/push detector shared by rule 1. The leading boundary accepts ; & |
+# so `true;git commit …` (no space after the separator) is caught; the
+# `git(… -opt …)*` middle allows git global options between `git` and the
+# subcommand (`git -c k=v commit …`).
+git_cp='(^|[[:space:]]|[;&|])git([[:space:]]+-[a-zA-Z-]+(=[^[:space:]]+)?([[:space:]]+[^-][^[:space:]]*)?)*[[:space:]]+(commit|push)'
+
 # 1. Skipping quality gates / hooks — defeats the whole point of the harness.
-if printf '%s' "$cmd" | grep -qE '(^|[[:space:]])git[[:space:]]+(commit|push)([[:space:]]|.)*(--no-verify|[[:space:]]-n([[:space:]]|$))'; then
+#    Two checks: the literal `--no-verify` over `scan` (quotes kept, so a quoted
+#    flag is still caught), and `-[a-zA-Z]*n[a-zA-Z]*` over `scan_flags` (quotes
+#    dropped) to catch `-n` folded into a combined short-flag token
+#    (`git commit -qn`/`-nq`) without a hyphen-word in a message tripping it.
+if printf '%s' "$scan"       | grep -qE "${git_cp}([[:space:]]|.)*--no-verify" \
+  || printf '%s' "$scan_flags" | grep -qE "${git_cp}([[:space:]]|.)*[[:space:]]-[a-zA-Z]*n[a-zA-Z]*([[:space:]]|\$)"; then
   block "git commit/push con --no-verify (saltarse los hooks/gates)"
 fi
 
 # 2. Force-push to the base branch. force-with-lease is allowed (safe rebase
 #    flow on feature branches); bare --force/-f against the base branch is not.
-if printf '%s' "$cmd" | grep -qE '(^|[[:space:]])git[[:space:]]+push' \
-  && printf '%s' "$cmd" | grep -qE '(--force([[:space:]]|$)|[[:space:]]-f([[:space:]]|$)|[[:space:]]\+)' \
-  && ! printf '%s' "$cmd" | grep -qE 'force-with-lease' \
-  && printf '%s' "$cmd" | grep -qE "(^|[[:space:]+/])${base}([[:space:]]|\$)"; then
+#    The leading boundary accepts ; & | so `true;git push --force main` (no
+#    space after the separator) is caught too. The `git(… -opt …)*` middle
+#    allows git global options before `push` (`git -C /repo push --force …`).
+if printf '%s' "$scan" | grep -qE '(^|[[:space:]]|[;&|])git([[:space:]]+-[a-zA-Z-]+(=[^[:space:]]+)?([[:space:]]+[^-][^[:space:]]*)?)*[[:space:]]+push' \
+  && printf '%s' "$scan" | grep -qE '(--force([[:space:]]|$)|[[:space:]]-f([[:space:]]|$)|[[:space:]]\+)' \
+  && ! printf '%s' "$scan" | grep -qE 'force-with-lease' \
+  && printf '%s' "$scan" | grep -qE "(^|[[:space:]+/])${base}([[:space:]]|\$)"; then
   block "force-push a la rama base '${base}'"
 fi
 

package/dist/assets/core/core-assets/hooks/quality-gate-pre-commit.sh

@@ -2,7 +2,7 @@
 #
 # Pre-commit / pre-push quality gate hook.
 # Reads the tool input (from Claude Code's PreToolUse Bash matcher) and runs
-# the project's `qualityGate.fast` command before allowing the commit/push.
+# the project's `qualityGate.fast` command before allowing the commit.
 #
 # The managed block below is regenerated by `navori render` and must NOT be
 # edited by hand. Add your repo-specific checks in the user section at the
@@ -51,35 +51,92 @@ is_pm() {
 run_gate() {
   echo "[navori] running quality-gate fast: $1" >&2
   eval "$1" || {
-    echo "[navori] quality-gate fast failed. Commit/push aborted." >&2
+    echo "[navori] quality-gate fast failed. Commit aborted." >&2
     exit 2
   }
 }
 
-case "$cmd" in
-  'git commit'*|'git push'*)
-    gate="{{qualityGate.fast}}"
-    gate_bin="${gate%% *}"
-    if command -v "$gate_bin" >/dev/null 2>&1; then
-      run_gate "$gate"
+# --- shared gate detection (keep IN SYNC across sibling hooks) --------------
+# Detect a `git commit` invocation anywhere in a (possibly
+# compound) command. Splits $1 on the shell separators && || ; | and newlines,
+# strips leading whitespace plus simple `VAR=value` env prefixes from each
+# segment, and returns 0 if ANY segment STARTS with `git commit` on
+# a word boundary. Replaces literal-prefix `case` matching, which silently
+# skipped the gate for `cd x && git commit`, `echo y; git commit`, or a leading
+# space (#88: NEVER skip the gate silently). Because it matches a segment START,
+# a quoted `echo "git commit"` does NOT trigger it. Known limitation: it cannot
+# see through `sh -c`, `eval`, or obfuscation — a seatbelt, not a sandbox.
+# The IDENTICAL function body lives in the sibling gate scripts (they render
+# standalone, so there is no shared lib to import):
+#   plugins/jscpd/scripts/check-jscpd.sh
+#   plugins/semgrep/scripts/check-semgrep.sh
+#   plugins/cognitive/scripts/check-cognitive.sh
+is_git_commit() {
+  local input="$1" segment
+  # FIX B: join `\<newline>` continuations into a space FIRST, so a command
+  # split across lines with a trailing backslash stays ONE logical segment
+  # (otherwise the subcommand/flag lands in a segment not starting with git).
+  input="${input//\\$'\n'/ }"
+  input="${input//&&/$'\n'}"
+  input="${input//||/$'\n'}"
+  input="${input//;/$'\n'}"
+  input="${input//|/$'\n'}"
+  # `<<<` feeds the already-expanded value as data — no re-evaluation — so a
+  # command that contains backticks/$() is inspected, never executed.
+  while IFS= read -r segment; do
+    segment="${segment#"${segment%%[![:space:]]*}"}"        # strip leading ws
+    # FIX C: peel wrappers so `(git …`, `\git`, `command git …` and
+    # `VAR=val git …` all reduce to a plain `git …` before matching.
+    while [[ "$segment" == \(* ]]; do                       # strip leading ( runs
+      segment="${segment#\(}"
+      segment="${segment#"${segment%%[![:space:]]*}"}"
+    done
+    segment="${segment#\\}"                                 # strip a leading backslash (\git)
+    while [[ "$segment" =~ ^[A-Za-z_][A-Za-z0-9_]*= ]]; do  # strip VAR=val prefixes
+      case "$segment" in
+        *[[:space:]]*)
+          segment="${segment#*[[:space:]]}"
+          segment="${segment#"${segment%%[![:space:]]*}"}"
+          ;;
+        *) segment=""; break ;;
+      esac
+    done
+    if [[ "$segment" == command\ * ]]; then                 # strip a leading `command ` word
+      segment="${segment#command }"
+      segment="${segment#"${segment%%[![:space:]]*}"}"
+    fi
+    # FIX C: allow git global options between `git` and the subcommand
+    # (`git -c k=v commit`, `git -C /repo push`). Trailing boundary keeps
+    # `git commitgraph` / `git config …` from matching as commit.
+    if printf '%s' "$segment" | grep -qE '^git([[:space:]]+-[a-zA-Z-]+(=[^[:space:]]+)?([[:space:]]+[^-][^[:space:]]*)?)*[[:space:]]+commit([[:space:]]|$)'; then
+      return 0
+    fi
+  done <<< "$input"
+  return 1
+}
+
+if is_git_commit "$cmd"; then
+  gate="{{qualityGate.fast}}"
+  gate_bin="${gate%% *}"
+  if command -v "$gate_bin" >/dev/null 2>&1; then
+    run_gate "$gate"
+  else
+    # The declared runner isn't on PATH. If it's a package manager, detect the
+    # repo's real one from lockfiles and retry through it (a `pnpm run x` gate
+    # still runs in a bun-only checkout). #88: NEVER skip the gate silently —
+    # when nothing can run it, BLOCK the commit loudly instead of the old
+    # `exit 0` that handed a contributor zero quality gate without a word.
+    detected_pm="$(detect_pm)"
+    if is_pm "$gate_bin" && [ -n "$detected_pm" ] && [ "$detected_pm" != "$gate_bin" ] && command -v "$detected_pm" >/dev/null 2>&1; then
+      echo "[navori] '$gate_bin' no está en PATH; uso el package manager detectado por lockfile: '$detected_pm'." >&2
+      run_gate "$detected_pm ${gate#* }"
     else
-      # The declared runner isn't on PATH. If it's a package manager, detect the
-      # repo's real one from lockfiles and retry through it (a `pnpm run x` gate
-      # still runs in a bun-only checkout). #88: NEVER skip the gate silently —
-      # when nothing can run it, BLOCK the commit loudly instead of the old
-      # `exit 0` that handed a contributor zero quality gate without a word.
-      detected_pm="$(detect_pm)"
-      if is_pm "$gate_bin" && [ -n "$detected_pm" ] && [ "$detected_pm" != "$gate_bin" ] && command -v "$detected_pm" >/dev/null 2>&1; then
-        echo "[navori] '$gate_bin' no está en PATH; uso el package manager detectado por lockfile: '$detected_pm'." >&2
-        run_gate "$detected_pm ${gate#* }"
-      else
-        echo "[navori] quality-gate NO ejecutado: '$gate_bin' no está en PATH y no hay un package manager alternativo detectado que pueda correrlo." >&2
-        echo "[navori] Commit/push BLOQUEADO para no saltarnos el gate en silencio. Instala '$gate_bin' o usa 'git commit --no-verify' si de verdad quieres saltártelo." >&2
-        exit 2
-      fi
+      echo "[navori] quality-gate NO ejecutado: '$gate_bin' no está en PATH y no hay un package manager alternativo detectado que pueda correrlo." >&2
+      echo "[navori] Commit BLOQUEADO para no saltarnos el gate en silencio. Instala '$gate_bin' o usa 'git commit --no-verify' si de verdad quieres saltártelo." >&2
+      exit 2
     fi
-    ;;
-esac
+  fi
+fi
 
 # navori:user-section
 # user: agrega checks adicionales acá. `$cmd` ya está parseado del input

package/dist/assets/core/core-assets/managed/idioma-rol.md

@@ -2,3 +2,6 @@
 
 - Código y comentarios (JSDoc/docstrings): inglés. Chat: español MX.
 - Rol Tech Lead Senior. Antes de codear: ¿lo más simple? ¿legible en 6 meses? ¿mantiene patrón existente? Simplicidad > cleverness.
+- **Alcance de persona**: idioma y tono de esta sección rigen solo la respuesta directa al usuario (chat). No rigen artefactos generados (código, identificadores, comentarios, commits, título/descripción de PR, docs).
+- Default de artefactos: código e identificadores en inglés. Copy de UI, PRs y docs siguen el idioma configurado del proyecto (`language` en `navori.config.json`), no el idioma del chat.
+- Nunca inyectes tono o énfasis de persona (mayúsculas, exclamaciones, coloquialismos) en artefactos — eso es exclusivo del chat.

package/dist/assets/core/core-assets/presets/vite-react-ts/managed/stack.md

@@ -1,6 +1,6 @@
 ## Stack — Vite + React + TypeScript
 
-SPA sobre Vite + React 18 + TypeScript, agnóstica de UI lib (CSS Modules, Tailwind, styled-components, o una lib de componentes). Organización por feature: cada feature vive en su carpeta con sus componentes, hooks y estado local; lo compartido (UI primitives, utils, hooks genéricos) va a carpetas comunes. Los componentes son funcionales con hooks; nada de class components nuevos.
+SPA sobre Vite + React + TypeScript, agnóstica de UI lib (CSS Modules, Tailwind, styled-components, o una lib de componentes). Organización por feature: cada feature vive en su carpeta con sus componentes, hooks y estado local; lo compartido (UI primitives, utils, hooks genéricos) va a carpetas comunes. Los componentes son funcionales con hooks; nada de class components nuevos.
 
 Regla de oro: tipado estricto (sin `any` injustificado — ver el bloque de tipado); side-effects en `useEffect` con deps completas; data-fetching por la capa que use el repo (fetch/axios, TanStack Query si está — se inyecta como library-skill según deps). El estado del servidor NO se duplica en estado global; el estado global (Redux/Zustand/Context) es solo para lo genuinamente compartido y de cliente. Aplica la skill `new-feature` para dar de alta una feature nueva con la estructura del repo. Las skills de UI lib, forms y state se inyectan según las dependencias que detecte navori.
 

package/dist/assets/core/core-assets/skills/pr-create.md

@@ -2,6 +2,8 @@
 name: pr-create
 description: Crea un PR en GitHub contra la rama target del repo, delegando title/body a un modelo y validando el output. Antes de crear cualquier PR al cerrar el ciclo de un ticket (Fase 8 de ticket-intake).
 type: reference
+# maxWords raised above the 500 reference cap: el pre-flight bloqueante es load-bearing y no se puede recortar sin perder chequeos de seguridad.
+maxWords: 560
 ---
 
 # pr-create — crear PR contra `{{prTarget}}`
@@ -18,7 +20,7 @@ Al cierre del ciclo, tras el `APPROVED` del reviewer (Fase 8 de `ticket-intake`)
 2. **No estás en una rama protegida**: aborta si la rama actual es `main|master|{{branchBase}}|{{prTarget}}`.
 3. **`gh` autenticado**: `gh auth status`.
 4. **Gate verde en este turno**: `{{qualityGate.fast}}`. Falla → manda al implementer.
-5. **Review APPROVED** (si el harness está activo): `grep -q APPROVED .claude/progress/review_*.md`. Falla → manda al reviewer.
+5. **Review APPROVED de esta feature** (harness activo): `.claude/progress/review_<feature>.md` puntual — glob `review_*.md` no vale. Ausente/ambiguo/scope distinto → NO aprobado, manda al reviewer. Si lista archivos, compáralos con `git diff --name-only`: archivos tocados que el review NO cubre → NO aprobado, aborta y devuelve al reviewer (no basta con mencionar la diferencia y seguir). <!-- Mantén este chequeo de cobertura en sync con `agents/commit-pr-pilot.md`. -->
 6. **Hay commits para el PR**: `git fetch origin {{prTarget}} --quiet` y `git log origin/{{prTarget}}..HEAD --oneline`. Vacío → nada que PR-ear.
 7. **Branch sincronizada**: `git log HEAD..origin/{{prTarget}} --oneline`. Si origin va adelante, rebase y pregunta.
 8. **Arrastre de commits** (solo si `{{branchBase}}` ≠ `{{prTarget}}`): `git rev-list --count origin/{{prTarget}}..origin/{{branchBase}}`. Si es > 0, `{{branchBase}}` va adelantado de `{{prTarget}}` y el PR arrastra esos commits ajenos: avisa y sugiere `git rebase origin/{{prTarget}}` antes de abrir.

package/dist/assets/core/core-assets/skills/review-diff.md

@@ -49,6 +49,7 @@ Si no llega a MEDIO, no lo reportes. Nada de "nitpick" ni "consider also". (Mape
 - `catch` que se traga el error sin propagar ni reportar → ALTO.
 - Operación que puede fallar (red, parse, IO) sin manejo, con el fallo visible al usuario → ALTO.
 - Loading/spinner que nunca se apaga en el path de error → ALTO.
+- Recurso abierto sin cleanup en el path de error (conexión, lock, stream, listener, subscription, timer): el happy path lo libera pero un `catch`/early-return lo filtra → ALTO.
 
 ## 4. Seguridad y autorización
 
@@ -68,18 +69,32 @@ Si no llega a MEDIO, no lo reportes. Nada de "nitpick" ni "consider also". (Mape
 - Casing/sufijos que rompen la convención del repo → MEDIO.
 - Convención de migración rota (cuando conviven código nuevo y legacy y hay un sufijo/carpeta esperado) → ALTO.
 
-## 7. Dead code y debug
+## 7. Sobre-ingeniería / abstracción especulativa
+
+Espejo de la escalera YAGNI del `implementer`: caza el código de **más**.
+
+- Abstracción (interface, capa, helper genérico, hook) con **un solo caller** y sin segundo consumidor a la vista → MEDIO (ALTO si acopla o complica un área crítica).
+- Dependencia nueva para lo que la stdlib, una feature nativa de la plataforma o una lib ya instalada resuelven en unas líneas → ALTO.
+- Parametrización, flags de config u opciones que nadie usa todavía ("por si acaso") → MEDIO.
+- Indirección o patrón (factory, wrapper, capa de eventos) que no elimina duplicación real ni cubre un requisito presente → MEDIO.
+- Atajo deliberado sin su marca (techo + disparador de upgrade) → MEDIO: la deuda muda es peor que la declarada.
+
+Regla: si quitar la abstracción deja el código **igual de correcto** y más corto, quitarla es el hallazgo.
+
+**No confundir con incompletitud.** Quitar el manejo de un edge case real, una validación o un path de error NO es simplificar — es un bug, y va a §1-§4 (no aquí). Esta dimensión ataca *estructura de más*, nunca *cobertura de menos*. Lo que la escalera YAGNI protege (trust boundaries, errores que evitan pérdida de datos, seguridad, accesibilidad) nunca es over-engineering.
+
+## 8. Dead code y debug
 
 - `console.log` / print de debug sin guard en código que se mergea → MEDIO (en código nuevo: ALTO).
 - Imports o variables sin usar → MEDIO.
 - Código comentado entero / `if (false)` / `// TODO: borrar` sin issue → MEDIO.
 
-## 8. Quality gate (corrido en este turno, no asumido)
+## 9. Quality gate (corrido en este turno, no asumido)
 
 - `{{qualityGate.fast}}` pasa → CRÍTICO si falla.
 - Cero errores/warnings nuevos vs baseline → ALTO si el diff los agrega.
 
-## 9. Commit y PR
+## 10. Commit y PR
 
 - Commits siguen la convención del repo → MEDIO si rompe.
 - Cambios a manifest/lockfile sin razón clara en la descripción → ALTO.
@@ -98,7 +113,7 @@ Presta atención extra si el diff toca las áreas críticas que declara tu repo
 ## Conexión con el harness
 
 - `reviewer`: aplica este skill en la Pasada 2 (code quality). CRÍTICO/ALTO mapean a issues con confidence ≥80 (bloquean APPROVED); MEDIO a observaciones informativas (50-79).
-- `verify-before-done`: el quality gate del §8 se corre en este turno, no se asume del informe del implementer.
+- `verify-before-done`: el quality gate del §9 se corre en este turno, no se asume del informe del implementer.
 
 <!-- navori:user-section -->
 ## Reglas específicas del repo

package/dist/assets/plugins/cognitive/scripts/check-cognitive.sh

@@ -9,13 +9,13 @@
 # it once:
 #   (cd .claude/scripts/cognitive-tool && bun install)
 #
-# Triggered as a PreToolUse(Bash) hook (gated to git commit/push) and as a
+# Triggered as a PreToolUse(Bash) hook (gated to git commit) and as a
 # Stop hook (runs unconditionally at session close). Skips silently when the
 # toolchain is not bootstrapped — the gate is optional.
 
 set -euo pipefail
 
-# PreToolUse(Bash) passes the command — gate to commit/push. The Stop hook
+# PreToolUse(Bash) passes the command — gate to commit. The Stop hook
 # passes no command — run unconditionally at session close. Extract without
 # hard-depending on jq (not preinstalled on macOS): try jq, then node (Claude
 # Code's own runtime), then a best-effort sed unwrap. No command extracted →
@@ -31,11 +31,68 @@ extract_cmd() {
   printf '%s' "$payload" | sed -n 's/.*"command"[[:space:]]*:[[:space:]]*"\(.*\)".*/\1/p'
 }
 cmd=$(extract_cmd)
-if [ -n "$cmd" ]; then
-  case "$cmd" in
-    'git commit'*|'git push'*) ;;
-    *) exit 0 ;;
-  esac
+
+# --- shared gate detection (keep IN SYNC across sibling hooks) --------------
+# Detect a `git commit` invocation anywhere in a (possibly
+# compound) command. Splits $1 on the shell separators && || ; | and newlines,
+# strips leading whitespace plus simple `VAR=value` env prefixes from each
+# segment, and returns 0 if ANY segment STARTS with `git commit` on
+# a word boundary. Replaces literal-prefix `case` matching, which silently
+# skipped the gate for `cd x && git commit`, `echo y; git commit`, or a leading
+# space. Because it matches a segment START, a quoted `echo "git commit"` does
+# NOT trigger it. Known limitation: it cannot see through `sh -c`, `eval`, or
+# obfuscation — a seatbelt, not a sandbox. Body duplicated across the navori quality hooks (they render standalone — no
+# shared lib). The quality-gate/jscpd/cognitive copies gate `git commit` ONLY;
+# the semgrep copy also gates `git push` and `gh pr create` (remote-push
+# security backstop). Keep in sync.
+is_git_commit() {
+  local input="$1" segment
+  # FIX B: join `\<newline>` continuations into a space FIRST, so a command
+  # split across lines with a trailing backslash stays ONE logical segment
+  # (otherwise the subcommand/flag lands in a segment not starting with git).
+  input="${input//\\$'\n'/ }"
+  input="${input//&&/$'\n'}"
+  input="${input//||/$'\n'}"
+  input="${input//;/$'\n'}"
+  input="${input//|/$'\n'}"
+  # `<<<` feeds the already-expanded value as data — no re-evaluation — so a
+  # command that contains backticks/$() is inspected, never executed.
+  while IFS= read -r segment; do
+    segment="${segment#"${segment%%[![:space:]]*}"}"        # strip leading ws
+    # FIX C: peel wrappers so `(git …`, `\git`, `command git …` and
+    # `VAR=val git …` all reduce to a plain `git …` before matching.
+    while [[ "$segment" == \(* ]]; do                       # strip leading ( runs
+      segment="${segment#\(}"
+      segment="${segment#"${segment%%[![:space:]]*}"}"
+    done
+    segment="${segment#\\}"                                 # strip a leading backslash (\git)
+    while [[ "$segment" =~ ^[A-Za-z_][A-Za-z0-9_]*= ]]; do  # strip VAR=val prefixes
+      case "$segment" in
+        *[[:space:]]*)
+          segment="${segment#*[[:space:]]}"
+          segment="${segment#"${segment%%[![:space:]]*}"}"
+          ;;
+        *) segment=""; break ;;
+      esac
+    done
+    if [[ "$segment" == command\ * ]]; then                 # strip a leading `command ` word
+      segment="${segment#command }"
+      segment="${segment#"${segment%%[![:space:]]*}"}"
+    fi
+    # FIX C: allow git global options between `git` and the subcommand
+    # (`git -c k=v commit`, `git -C /repo push`). Trailing boundary keeps
+    # `git commitgraph` / `git config …` from matching as commit.
+    if printf '%s' "$segment" | grep -qE '^git([[:space:]]+-[a-zA-Z-]+(=[^[:space:]]+)?([[:space:]]+[^-][^[:space:]]*)?)*[[:space:]]+commit([[:space:]]|$)'; then
+      return 0
+    fi
+  done <<< "$input"
+  return 1
+}
+
+# No command extracted (empty $cmd) → run unconditionally (Stop hook path). A
+# real command that is NOT a git commit → skip. Anything else → scan.
+if [ -n "$cmd" ] && ! is_git_commit "$cmd"; then
+  exit 0
 fi
 
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"

package/dist/assets/plugins/engram/managed/engram-protocol.md

@@ -2,4 +2,5 @@
 
 - `mem_save` proactivo tras decisión / bug-fix-con-root-cause / convención / discovery / preferencia confirmada.
 - `mem_search` al inicio si el primer mensaje referencia el proyecto. Verificar en código que lo recordado siga existiendo antes de afirmarlo.
+- Lo recordado es una foto de cuando se guardó, no un hecho vigente. Si el sistema expone vigencia (`active` / `needs_review`), trata `needs_review` como contexto stale: avisa al usuario y verifícalo contra el código actual antes de apoyarte en eso.
 - `mem_session_summary` obligatorio antes de "listo": Goal · Discoveries · Accomplished · Next Steps · Relevant Files.

package/dist/assets/plugins/jscpd/scripts/check-jscpd.sh

@@ -3,12 +3,12 @@
 # `{{branchBase}}`. Skips silently if jscpd or git are absent — the tool is
 # optional, not a hard dependency of the project.
 #
-# Triggered as a PreToolUse(Bash) hook, gated to git commit/push — so the
+# Triggered as a PreToolUse(Bash) hook, gated to git commit — so the
 # duplication check runs right before code lands, not on every turn.
 
 set -euo pipefail
 
-# PreToolUse(Bash) passes the command — gate to commit/push. Extract without
+# PreToolUse(Bash) passes the command — gate to commit. Extract without
 # hard-depending on jq (not preinstalled on macOS): try jq, then node (Claude
 # Code's own runtime), then a best-effort sed unwrap. No command extracted →
 # empty $cmd → runs unconditionally (defensive: never silently skip a commit).
@@ -23,11 +23,68 @@ extract_cmd() {
   printf '%s' "$payload" | sed -n 's/.*"command"[[:space:]]*:[[:space:]]*"\(.*\)".*/\1/p'
 }
 cmd=$(extract_cmd)
-if [ -n "$cmd" ]; then
-  case "$cmd" in
-    'git commit'*|'git push'*) ;;
-    *) exit 0 ;;
-  esac
+
+# --- shared gate detection (keep IN SYNC across sibling hooks) --------------
+# Detect a `git commit` invocation anywhere in a (possibly
+# compound) command. Splits $1 on the shell separators && || ; | and newlines,
+# strips leading whitespace plus simple `VAR=value` env prefixes from each
+# segment, and returns 0 if ANY segment STARTS with `git commit` on
+# a word boundary. Replaces literal-prefix `case` matching, which silently
+# skipped the gate for `cd x && git commit`, `echo y; git commit`, or a leading
+# space. Because it matches a segment START, a quoted `echo "git commit"` does
+# NOT trigger it. Known limitation: it cannot see through `sh -c`, `eval`, or
+# obfuscation — a seatbelt, not a sandbox. Body duplicated across the navori quality hooks (they render standalone — no
+# shared lib). The quality-gate/jscpd/cognitive copies gate `git commit` ONLY;
+# the semgrep copy also gates `git push` and `gh pr create` (remote-push
+# security backstop). Keep in sync.
+is_git_commit() {
+  local input="$1" segment
+  # FIX B: join `\<newline>` continuations into a space FIRST, so a command
+  # split across lines with a trailing backslash stays ONE logical segment
+  # (otherwise the subcommand/flag lands in a segment not starting with git).
+  input="${input//\\$'\n'/ }"
+  input="${input//&&/$'\n'}"
+  input="${input//||/$'\n'}"
+  input="${input//;/$'\n'}"
+  input="${input//|/$'\n'}"
+  # `<<<` feeds the already-expanded value as data — no re-evaluation — so a
+  # command that contains backticks/$() is inspected, never executed.
+  while IFS= read -r segment; do
+    segment="${segment#"${segment%%[![:space:]]*}"}"        # strip leading ws
+    # FIX C: peel wrappers so `(git …`, `\git`, `command git …` and
+    # `VAR=val git …` all reduce to a plain `git …` before matching.
+    while [[ "$segment" == \(* ]]; do                       # strip leading ( runs
+      segment="${segment#\(}"
+      segment="${segment#"${segment%%[![:space:]]*}"}"
+    done
+    segment="${segment#\\}"                                 # strip a leading backslash (\git)
+    while [[ "$segment" =~ ^[A-Za-z_][A-Za-z0-9_]*= ]]; do  # strip VAR=val prefixes
+      case "$segment" in
+        *[[:space:]]*)
+          segment="${segment#*[[:space:]]}"
+          segment="${segment#"${segment%%[![:space:]]*}"}"
+          ;;
+        *) segment=""; break ;;
+      esac
+    done
+    if [[ "$segment" == command\ * ]]; then                 # strip a leading `command ` word
+      segment="${segment#command }"
+      segment="${segment#"${segment%%[![:space:]]*}"}"
+    fi
+    # FIX C: allow git global options between `git` and the subcommand
+    # (`git -c k=v commit`, `git -C /repo push`). Trailing boundary keeps
+    # `git commitgraph` / `git config …` from matching as commit.
+    if printf '%s' "$segment" | grep -qE '^git([[:space:]]+-[a-zA-Z-]+(=[^[:space:]]+)?([[:space:]]+[^-][^[:space:]]*)?)*[[:space:]]+commit([[:space:]]|$)'; then
+      return 0
+    fi
+  done <<< "$input"
+  return 1
+}
+
+# No command extracted (empty $cmd) → run unconditionally. A real command that
+# is NOT a git commit → skip. Anything else → fall through and scan.
+if [ -n "$cmd" ] && ! is_git_commit "$cmd"; then
+  exit 0
 fi
 
 if ! command -v jscpd >/dev/null 2>&1; then