navori 0.2.7 → 0.2.8

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

@@ -1,13 +1,15 @@
 ---
 name: leader
-description: Orquestador. Recibe la tarea, divide el trabajo y lanza subagentes en paralelo. NUNCA escribe código directamente.
+description: NO invocar como subagente. Playbook de orquestación que el agente principal ENCARNA (ver "## Rol: orquestador" en CLAUDE.md). Delegarlo a un subagente serializa el trabajo y tira el paralelismo.
 tools: Read, Glob, Grep, Bash, Agent
 model: {{models.leader}}
 ---
 
-# Agente Líder (Orquestador)
+# Playbook del Orquestador (encarnado por el agente principal)
 
-Tu único trabajo es **descomponer y coordinar**, nunca implementar.
+> Este archivo es **referencia de profundidad** — el rol de orquestador **lo encarna el agente principal**, no un subagente. La mecánica esencial (tabla de escalado, paralelismo, síntesis) vive inline en el bloque "## Rol: orquestador" de `CLAUDE.md`, que se auto-carga. Aquí está el detalle extendido y, abajo, las **Reglas del proyecto**. NO invoques `Agent(subagent_type: leader)`.
+
+Tu único trabajo como orquestador es **descomponer y coordinar**, nunca implementar.
 
 ## Protocolo de arranque
 

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

@@ -13,7 +13,24 @@
 # bottom — `$cmd` is already parsed and in scope there.
 set -euo pipefail
 
-cmd=$(jq -r '.tool_input.command // empty' 2>/dev/null || true)
+# Extract .tool_input.command from the PreToolUse payload WITHOUT hard-depending
+# on jq (NOT preinstalled on macOS — a missing jq used to make this guard wave
+# every command through). Try jq, then node (Claude Code's own runtime), and if
+# no JSON parser is on PATH fall back to a best-effort sed unwrap so the guard
+# still inspects the command instead of failing open.
+payload=$(cat)
+extract_cmd() {
+  if command -v jq >/dev/null 2>&1; then
+    printf '%s' "$payload" | jq -r '.tool_input.command // empty' 2>/dev/null && return 0
+  fi
+  if command -v node >/dev/null 2>&1; then
+    printf '%s' "$payload" | node -e 'let s="";process.stdin.on("data",c=>s+=c).on("end",()=>{try{process.stdout.write(String(JSON.parse(s)?.tool_input?.command??""))}catch{}})' 2>/dev/null && return 0
+  fi
+  # No JSON parser on PATH: pull the "command" string out with sed. Best-effort
+  # (won't handle a literal embedded quote), but far better than failing open.
+  printf '%s' "$payload" | sed -n 's/.*"command"[[:space:]]*:[[:space:]]*"\(.*\)".*/\1/p'
+}
+cmd=$(extract_cmd)
 [ -z "$cmd" ] && exit 0
 
 base="{{branchBase}}"

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

@@ -9,7 +9,20 @@
 # bottom — they keep `cmd` and the original exit codes in scope.
 set -euo pipefail
 
-cmd=$(jq -r '.tool_input.command // empty' 2>/dev/null || true)
+# Extract .tool_input.command WITHOUT hard-depending on jq (not preinstalled on
+# macOS). Try jq, then node (Claude Code's own runtime), then a best-effort sed
+# unwrap. If nothing extracts a command $cmd stays empty and the gate skips.
+payload=$(cat)
+extract_cmd() {
+  if command -v jq >/dev/null 2>&1; then
+    printf '%s' "$payload" | jq -r '.tool_input.command // empty' 2>/dev/null && return 0
+  fi
+  if command -v node >/dev/null 2>&1; then
+    printf '%s' "$payload" | node -e 'let s="";process.stdin.on("data",c=>s+=c).on("end",()=>{try{process.stdout.write(String(JSON.parse(s)?.tool_input?.command??""))}catch{}})' 2>/dev/null && return 0
+  fi
+  printf '%s' "$payload" | sed -n 's/.*"command"[[:space:]]*:[[:space:]]*"\(.*\)".*/\1/p'
+}
+cmd=$(extract_cmd)
 
 case "$cmd" in
   'git commit'*|'git push'*)

package/dist/assets/core/core-assets/managed/orquestacion.md

@@ -1,15 +1,40 @@
-## Rol: orquestador
+## Rol: orquestador (centro de gravedad)
 
-Ante una tarea no trivial **actúas como el `leader`** (`.claude/agents/leader.md`): descompones y coordinas, no implementas el código tú directamente. La inteligencia de orquestación —tabla de escalado, paralelismo, síntesis— vive en ese archivo; encárnala. El catálogo de subagentes está en "## Agentes disponibles".
+Ante una tarea no trivial **tú actúas como el orquestador**: descompones y coordinas, no implementas el código directamente. Este rol **lo encarnas tú, el agente principal** — es el único que puede abrir un abanico de subagentes en paralelo. **NUNCA lo delegues**: no invoques `Agent(subagent_type: leader)`. El archivo `.claude/agents/leader.md` es referencia de profundidad (y las "Reglas del proyecto"), no un subagente para delegar; delegarlo serializa el trabajo y tira el paralelismo. El catálogo de subagentes hoja está en "## Agentes disponibles".
 
-### Cómo operas
+### Cómo descomponer (tabla de escalado)
 
-- **Descompón** la tarea y, para cada pieza, **lanza el subagente apropiado** vía la tool `Agent`: investigación → `researcher`/`explorer`; implementación → `implementer`; validación → `reviewer`; cierre con PR → `commit-pr-pilot`.
-- **Paraleliza lo independiente**: si necesitas varios investigadores (o varios `implementer` de scopes disjuntos), **emite todas las llamadas `Agent` en un mismo turno** — no una, esperar, otra. Es la palanca que más agiliza. El detalle (fan-out → síntesis, implementers que no se pisen) está en `leader.md`.
-- **Sintetiza tú**: los subagentes escriben en `.claude/progress/<archivo>.md` y te devuelven solo la referencia. Recopila los N y analiza a fondo antes de decidir.
+| Complejidad | Subagentes |
+|---|---|
+| Trivial (1 archivo) | 1 `implementer` |
+| Media (2–3 archivos) | 1 `implementer` → 1 `reviewer` |
+| Multi-bug independiente (sin shared state) | N `implementer` en paralelo (1 por bug, scopes aislados) → 1 `reviewer` que valida los N diffs juntos |
+| Compleja (migración, refactor multi-capa) | `ticket-audit` → 2–3 `researcher`/`explorer` en paralelo → `implementer` → `reviewer` → `commit-pr-pilot` |
+| Muy compleja | Divide en sub-tareas y re-aplica la tabla |
+
+Investigación con preguntas acotadas → `researcher`; mapas amplios (¿dónde vive X?) → `explorer`. Con audit previo, pásale al `implementer` la ruta de `.claude/progress/audit_<ID>.md`.
+
+### Paralelismo (la palanca — mecánica, no opcional)
+
+El paralelismo es **analítico**, no solo velocidad: el valor está en partir el problema en piezas genuinamente independientes y en cómo integras lo que vuelve. La mecánica: cuando la tabla dice "en paralelo", eso se logra emitiendo **TODAS las llamadas `Agent` en un MISMO turno**. Claude por defecto las lanza en serie; el paralelo hay que pedirlo explícito, en un solo mensaje.
+
+- ✅ En un mensaje, invoca `Agent` 3 veces (`explorer` auth, db, api). Corren concurrentes; el total ≈ el más lento.
+- ❌ Invocar auth, esperar su `done -> archivo`, luego db, luego api. Eso es serie y tira lo que el paralelo ahorra.
+
+Regla: sub-tareas **independientes** (no comparten estado ni una depende del output de otra) → mismo turno. Serializa solo con dependencia real (`implementer` → `reviewer`). **`implementer` en paralelo SOLO con archivos disjuntos** (dos que tocan el mismo archivo se pisan → van en serie; en la duda, serie). Reparte el scope explícito antes de abrir el abanico.
+
+**Fan-out → síntesis:** para una pregunta amplia, descompónla en sub-preguntas y lanza un investigador por cada una en paralelo. Cuando vuelven los `done -> archivo`, **recopila y analiza a fondo TÚ**: lee los N archivos juntos, cruza hallazgos (contradicciones, gaps, qué falta) y recién ahí decides la implementación. La síntesis no se delega.
+
+### Ejecución continua (no pausar entre tareas)
+
+Aprobado el plan/scope, ejecuta TODAS las sub-tareas sin pedir confirmación entre nodos. No hagas "hice la 1, ¿sigo con la 2?" — ejecuta el plan. Solo paras por: **BLOCKED** (subagente bloqueado que no puedes resolver), **spec ambigua mid-flight** (gap real fuera de scope), o **ciclo completo** (listo para PR). Cap: 2 ciclos `CHANGES_REQUESTED` sobre la misma tarea → escala al usuario en vez de reintentar en loop.
+
+### Síntesis sin teléfono descompuesto
+
+Instruye a los subagentes a **escribir en `.claude/progress/<archivo>.md`**; tú recibes solo `done -> archivo`. Verifica el diff/evidencia tú mismo, no confíes ciego en el reporte. Al cerrar el ciclo, cuando `review_<feature>.md` diga `APPROVED`, invoca `commit-pr-pilot` (pre-flight: working tree limpio, no en `{{branchBase}}`, `{{qualityGate.fast}}` verde, `gh auth status` ok). Si dice `CHANGES_REQUESTED`, lanza otro `implementer` — no el pilot.
 
 ### Cuándo NO orquestar (hazlo tú directo)
 
-- Pregunta conceptual o lectura pura → responde sin subagentes.
-- Cambios en `docs/`, `.claude/`, `CLAUDE.md`, `progress/` → edítalos tú.
-- Una sola línea trivial en un archivo conocido → puede no valer el overhead.
+- Pregunta conceptual / lectura pura → responde sin subagentes.
+- Cambios en `docs/`, `.claude/`, `CLAUDE.md`, `progress/` → **edítalos tú** (esos sí los tocas; el código fuente del proyecto NUNCA — eso es del `implementer`).
+- Una sola línea trivial en un archivo conocido → puede no valer el overhead del fan-out. El fan-out cuesta contexto; no abras 5 explorers para una tarea chica.

package/dist/assets/core/core-assets/presets/express/managed/stack.md

@@ -0,0 +1,20 @@
+## Stack — Express (TypeScript)
+
+Backend HTTP sobre Express en TypeScript, agnóstico de base de datos (Socket.IO, PeerJS, DB nativo, sin DB, etc.). Las peticiones fluyen en capas: `route → validate(schema) → asyncHandler → controller → capa de datos → ApiResponse`. Los errores se propagan vía `ApiError` y las respuestas se envuelven en `ApiResponse`. El logging va por el `Logger` de winston, nunca `console.log`.
+
+Regla de oro: nada de `res.json` / `res.status(500)` crudos; nada de `console.log`; nada de `process.env` fuera del módulo de config. La validación SIEMPRE ocurre en el boundary (con el validador del repo — Zod o Joi). Aplica las skills `express-routes` y `winston-logging` del preset según la capa que toques. Las skills de la capa de datos (mongoose, socketio, etc.) y de validación se inyectan según las dependencias que detecte navori en el repo — si están en `.claude/skills/`, aplícalas.
+
+El trabajo de un ticket sigue el pipeline documentado en la skill `ticket-intake` (la orquestadora). No es un generador de specs: es un protocolo que el orquestador ejecuta invocando agentes y skills en orden, con gates objetivos y artefactos en `.claude/progress/`. Mapeo de fases a la infraestructura de navori:
+
+| Fase | Quién la cubre | Artefacto |
+|---|---|---|
+| Audit | agente `ticket-audit` | `audit_<id>.md` |
+| Explore | agente `explorer` (2-3 en paralelo) | `explore_<dim>.md` |
+| Design | skill `new-endpoint` según alcance | (en el plan) |
+| Implement | agente `implementer` (aplica las skills de stack) | `impl_<feature>.md` |
+| Verify | skill core `verify-before-done` (Iron Law) | (evidencia en turno) |
+| Review | agente `reviewer` + skill core `review-diff` | `review_<feature>.md` |
+| Debug | skill core `loop-back-debug` | — |
+| PR | skill `pr-create` | URL del PR |
+
+navori bootstrapea `current.md` e `history.md`; el resto de artefactos los crea el flujo en runtime.

package/dist/assets/core/core-assets/presets/express.json

@@ -0,0 +1,44 @@
+{
+  "$schema": "https://navori.dev/schema/navori.preset.v1.json",
+  "id": "express",
+  "displayName": "Express backend (DB-agnostic)",
+  "extends": "core",
+  "extras": {
+    "managed": [
+      {
+        "id": "stack-express",
+        "relPath": "presets/express/managed/stack.md"
+      }
+    ],
+    "agents": [],
+    "skills": [
+      {
+        "id": "express-routes",
+        "relPath": "presets/express-mongoose/skills/express-routes.md",
+        "destRelPath": ".claude/skills/express-routes.md"
+      },
+      {
+        "id": "winston-logging",
+        "relPath": "presets/express-mongoose/skills/winston-logging.md",
+        "destRelPath": ".claude/skills/winston-logging.md"
+      },
+      {
+        "id": "new-endpoint",
+        "relPath": "presets/express-mongoose/skills/new-endpoint.md",
+        "destRelPath": ".claude/skills/new-endpoint.md"
+      },
+      {
+        "id": "ticket-intake",
+        "relPath": "presets/express-mongoose/skills/ticket-intake.md",
+        "destRelPath": ".claude/skills/ticket-intake.md"
+      },
+      {
+        "id": "pr-create",
+        "relPath": "presets/express-mongoose/skills/pr-create.md",
+        "destRelPath": ".claude/skills/pr-create.md"
+      }
+    ],
+    "hooks": []
+  },
+  "invariants": ["express-routes", "asyncHandler", "ApiResponse", "ticket-intake"]
+}

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

@@ -0,0 +1,7 @@
+## 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.
+
+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.
+
+El trabajo de un ticket sigue el pipeline de la infraestructura de navori: `ticket-audit` → `explorer` (en paralelo) → `implementer` (aplica las skills de stack) → `verify-before-done` → `reviewer` + `review-diff` → `commit-pr-pilot`. navori bootstrapea `current.md` e `history.md`; el resto de artefactos los crea el flujo en runtime bajo `.claude/progress/`.

package/dist/assets/core/core-assets/presets/vite-react-ts.json

@@ -0,0 +1,23 @@
+{
+  "$schema": "https://navori.dev/schema/navori.preset.v1.json",
+  "id": "vite-react-ts",
+  "displayName": "Vite + React + TS SPA (UI-lib-agnostic)",
+  "extends": "core",
+  "extras": {
+    "managed": [
+      {
+        "id": "stack-vite-react-ts",
+        "relPath": "presets/vite-react-ts/managed/stack.md"
+      }
+    ],
+    "agents": [],
+    "skills": [
+      {
+        "id": "new-feature",
+        "relPath": "presets/vite-react-ts-mantine/skills/new-feature.md",
+        "destRelPath": ".claude/skills/new-feature.md"
+      }
+    ],
+    "hooks": []
+  }
+}

package/dist/assets/core/core-assets/skills/loop-back-debug.md

@@ -87,7 +87,7 @@ No es debilidad — es eficiencia. 3 intentos a ciegas valen menos que 1 convers
 ## Conexión con el resto del harness
 
 - `implementer`: invoca este skill cuando el primer fix no resuelve el síntoma. NO devuelve `done` hasta haber pasado por Reset hipótesis si el repro inicial falla.
-- `verify-before-done`: este skill se aplica AGAS de verify-before-done — primero validas que el fix realmente arregló el síntoma (esto), luego validas que el resto del quality gate sigue verde (verify-before-done).
+- `verify-before-done`: este skill se aplica ANTES de verify-before-done — primero validas que el fix realmente arregló el síntoma (esto), luego validas que el resto del quality gate sigue verde (verify-before-done).
 - `ticket-audit`: cuando un bug entra al agente ticket-audit, la "Hipótesis de causa raíz" es el primer candidate del loop. Si el fix de esa hipótesis no funciona, ticket-audit puede ser reinvocado con la info nueva.
 
 ## Cierre

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

@@ -16,8 +16,21 @@
 set -euo pipefail
 
 # PreToolUse(Bash) passes the command — gate to commit/push. The Stop hook
-# passes no command — run unconditionally at session close.
-cmd=$(jq -r '.tool_input.command // empty' 2>/dev/null || true)
+# 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 →
+# empty $cmd → runs unconditionally.
+payload=$(cat)
+extract_cmd() {
+  if command -v jq >/dev/null 2>&1; then
+    printf '%s' "$payload" | jq -r '.tool_input.command // empty' 2>/dev/null && return 0
+  fi
+  if command -v node >/dev/null 2>&1; then
+    printf '%s' "$payload" | node -e 'let s="";process.stdin.on("data",c=>s+=c).on("end",()=>{try{process.stdout.write(String(JSON.parse(s)?.tool_input?.command??""))}catch{}})' 2>/dev/null && return 0
+  fi
+  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'*) ;;

package/dist/assets/plugins/engram/skills/engram-leader.md

@@ -1,14 +1,14 @@
 ---
 name: engram-leader-extension
-description: Protocolo Engram para el agente líder. Buscá contexto antes de descomponer, guardá decisiones proactivamente, cerrá sesión con summary.
+description: Protocolo Engram para el agente líder. Busca contexto antes de descomponer, guarda decisiones proactivamente, cierra sesión con summary.
 type: behavior
 ---
 
 ## Engram (memoria persistente)
 
-Antes de descomponer trabajo: **buscá contexto** con `mem_search` usando keywords del ticket. Si encontrás un audit previo de la misma área o una decisión arquitectónica relacionada, leelo antes de tirar al `implementer`. No re-descubrir lo que ya está guardado.
+Antes de descomponer trabajo: **busca contexto** con `mem_search` usando keywords del ticket. Si encuentras un audit previo de la misma área o una decisión arquitectónica relacionada, léelo antes de tirar al `implementer`. No re-descubrir lo que ya está guardado.
 
-Después de cada decisión arquitectónica, plugin nuevo o convención establecida en la sesión: `mem_save` proactivo con tipo apropiado (`decision`, `convention`, `pattern`, `bugfix`). Lead con qué decisión + por qué + dónde aplica.
+Después de cada decisión arquitectónica, plugin nuevo o convención establecida en la sesión: `mem_save` proactivo con tipo apropiado (`decision`, `convention`, `pattern`, `bugfix`). Encabeza con qué decisión + por qué + dónde aplica.
 
 Antes de cerrar la sesión: `mem_session_summary` obligatorio con:
 

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

@@ -9,8 +9,21 @@
 set -euo pipefail
 
 # PreToolUse(Bash) passes the command — gate to commit/push. The Stop hook
-# passes no command — run unconditionally at session close.
-cmd=$(jq -r '.tool_input.command // empty' 2>/dev/null || true)
+# 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 →
+# empty $cmd → runs unconditionally.
+payload=$(cat)
+extract_cmd() {
+  if command -v jq >/dev/null 2>&1; then
+    printf '%s' "$payload" | jq -r '.tool_input.command // empty' 2>/dev/null && return 0
+  fi
+  if command -v node >/dev/null 2>&1; then
+    printf '%s' "$payload" | node -e 'let s="";process.stdin.on("data",c=>s+=c).on("end",()=>{try{process.stdout.write(String(JSON.parse(s)?.tool_input?.command??""))}catch{}})' 2>/dev/null && return 0
+  fi
+  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'*) ;;

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

@@ -9,8 +9,21 @@
 set -euo pipefail
 
 # PreToolUse(Bash) passes the command — gate to commit/push. The Stop hook
-# passes no command — run unconditionally at session close.
-cmd=$(jq -r '.tool_input.command // empty' 2>/dev/null || true)
+# 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 →
+# empty $cmd → runs unconditionally.
+payload=$(cat)
+extract_cmd() {
+  if command -v jq >/dev/null 2>&1; then
+    printf '%s' "$payload" | jq -r '.tool_input.command // empty' 2>/dev/null && return 0
+  fi
+  if command -v node >/dev/null 2>&1; then
+    printf '%s' "$payload" | node -e 'let s="";process.stdin.on("data",c=>s+=c).on("end",()=>{try{process.stdout.write(String(JSON.parse(s)?.tool_input?.command??""))}catch{}})' 2>/dev/null && return 0
+  fi
+  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'*) ;;