karajan-code 1.36.0 → 1.37.0

package/docs/README.es.md

@@ -23,39 +23,40 @@
 
 ## Que es Karajan Code?
 
-Karajan Code (`kj`) orquesta multiples agentes de IA a traves de un pipeline automatizado: generacion de codigo, analisis estatico, revision de codigo, testing y auditorias de seguridad — todo en un solo comando.
+Karajan Code (`kj`) orquesta multiples agentes de IA a traves de un pipeline automatizado: generacion de codigo, analisis estatico, revision de codigo, testing y auditorias de seguridad. Todo en un solo comando.
 
 En lugar de ejecutar un agente de IA y revisar manualmente su output, `kj` encadena agentes con quality gates. El coder escribe codigo, SonarQube lo analiza, el reviewer lo revisa, y si hay problemas, el coder recibe otra oportunidad. Este bucle se repite hasta que el codigo es aprobado o se alcanza el limite de iteraciones.
 
 **Caracteristicas principales:**
 - **Pipeline multi-agente** con 11 roles configurables
 - **5 agentes de IA soportados**: Claude, Codex, Gemini, Aider, OpenCode
-- **Servidor MCP** con 20 herramientas — usa `kj` desde Claude, Codex o cualquier host compatible con MCP sin salir de tu agente. [Ver configuracion MCP](#servidor-mcp)
-- **Bootstrap obligatorio** — valida prerequisitos del entorno (git, remote, config, agentes, SonarQube) antes de cada ejecucion. Si algo falta, para con instrucciones claras
-- **TDD obligatorio** — se exigen cambios en tests cuando se modifican ficheros fuente
-- **Integracion con SonarQube** — analisis estatico con quality gates (requiere [Docker](#requisitos))
-- **Perfiles de revision** — standard, strict, relaxed, paranoid
-- **Tracking de presupuesto** — monitorizacion de tokens y costes por sesion con `--trace`
-- **Automatizacion Git** — auto-commit, auto-push, auto-PR tras aprobacion
-- **Gestion de sesiones** — pausa/reanudacion con deteccion fail-fast y limpieza automatica de sesiones expiradas
-- **Sistema de plugins** — extiende con agentes custom via `.karajan/plugins/`
-- **Checkpoints interactivos** — en lugar de matar tareas largas, pausa cada 5 minutos con un informe de progreso y te deja decidir: continuar, parar o ajustar el tiempo
-- **Descomposicion de tareas** — triage detecta cuando una tarea debe dividirse y recomienda subtareas; con integracion Planning Game, crea cards vinculadas con bloqueo secuencial
-- **Retry con backoff** — recuperacion automatica ante errores transitorios de API (429, 5xx) con backoff exponencial y jitter
-- **Pipeline stage tracker** — vista de progreso acumulativo durante `kj_run` mostrando que stages estan completadas, en ejecucion o pendientes — tanto en CLI como via eventos MCP para renderizado en tiempo real en el host
-- **Guardarrailes de observabilidad del planner** — telemetria continua de heartbeat/stall, proteccion configurable por silencio maximo (`session.max_agent_silence_minutes`) y limite duro de ejecucion (`session.max_planner_minutes`) para evitar bloqueos prolongados en `kj_plan`/planner
-- **Standby por rate-limit** — cuando un agente alcanza limites de uso, Karajan parsea el tiempo de espera, espera con backoff exponencial y reanuda automaticamente en vez de fallar
-- **Preflight handshake** — `kj_preflight` requiere confirmacion humana de la configuracion de agentes antes de ejecutar, previniendo que la IA cambie asignaciones silenciosamente
-- **Config de 3 niveles** — sesion > proyecto > global con scoping de `kj_agents`
-- **Mediacion inteligente del reviewer** — el scope filter difiere automaticamente issues del reviewer fuera de scope (ficheros no presentes en el diff) como deuda tecnica rastreada en vez de bloquear; Solomon media reviews estancados; el contexto diferido se inyecta en el prompt del coder
-- **Integracion con Planning Game** — combina opcionalmente con [Planning Game](https://github.com/AgenteIA-Geniova/planning-game) para gestion agil de proyectos (tareas, sprints, estimacion) — como Jira, pero open-source y nativo XP
-
-> **Mejor con MCP** — Karajan Code esta disenado para usarse como servidor MCP dentro de tu agente de IA (Claude, Codex, etc.). El agente envia tareas a `kj_run`, recibe notificaciones de progreso en tiempo real, y obtiene resultados estructurados — sin copiar y pegar.
+- **Servidor MCP** con 20 herramientas. Usa `kj` desde Claude, Codex o cualquier host compatible con MCP sin salir de tu agente. [Ver configuracion MCP](#servidor-mcp)
+- **Bootstrap obligatorio.** Valida prerequisitos del entorno (git, remote, config, agentes, SonarQube) antes de cada ejecucion. Si algo falta, para con instrucciones claras
+- **Guardia anti-inyeccion.** Escanea diffs antes de pasarlos a la IA: detecta directivas de override, Unicode invisible y payloads ocultos en comentarios. Tambien como GitHub Action en cada PR
+- **TDD obligatorio.** Se exigen cambios en tests cuando se modifican ficheros fuente
+- **Integracion con SonarQube.** Analisis estatico con quality gates (requiere [Docker](#requisitos))
+- **Perfiles de revision.** standard, strict, relaxed, paranoid
+- **Tracking de presupuesto.** Monitorizacion de tokens y costes por sesion con `--trace`
+- **Automatizacion Git.** Auto-commit, auto-push, auto-PR tras aprobacion
+- **Gestion de sesiones.** Pausa/reanudacion con deteccion fail-fast y limpieza automatica de sesiones expiradas
+- **Sistema de plugins.** Extiende con agentes custom via `.karajan/plugins/`
+- **Checkpoints interactivos.** En lugar de matar tareas largas, pausa cada 5 minutos con un informe de progreso y te deja decidir: continuar, parar o ajustar el tiempo
+- **Descomposicion de tareas.** Triage detecta cuando una tarea debe dividirse y recomienda subtareas; con integracion Planning Game, crea cards vinculadas con bloqueo secuencial
+- **Retry con backoff.** Recuperacion automatica ante errores transitorios de API (429, 5xx) con backoff exponencial y jitter
+- **Pipeline stage tracker.** Vista de progreso acumulativo durante `kj_run` mostrando que stages estan completadas, en ejecucion o pendientes, tanto en CLI como via eventos MCP para renderizado en tiempo real en el host
+- **Guardarrailes de observabilidad del planner.** Telemetria continua de heartbeat/stall, proteccion configurable por silencio maximo (`session.max_agent_silence_minutes`) y limite duro de ejecucion (`session.max_planner_minutes`) para evitar bloqueos prolongados en `kj_plan`/planner
+- **Standby por rate-limit.** Cuando un agente alcanza limites de uso, Karajan parsea el tiempo de espera, espera con backoff exponencial y reanuda automaticamente en vez de fallar
+- **Preflight handshake.** `kj_preflight` requiere confirmacion humana de la configuracion de agentes antes de ejecutar, previniendo que la IA cambie asignaciones silenciosamente
+- **Config de 3 niveles.** Sesion > proyecto > global con scoping de `kj_agents`
+- **Mediacion inteligente del reviewer.** El scope filter difiere automaticamente issues del reviewer fuera de scope (ficheros no presentes en el diff) como deuda tecnica rastreada en vez de bloquear; Solomon media reviews estancados; el contexto diferido se inyecta en el prompt del coder
+- **Integracion con Planning Game.** Combina opcionalmente con [Planning Game](https://github.com/AgenteIA-Geniova/planning-game) para gestion agil de proyectos (tareas, sprints, estimacion). Como Jira, pero open-source y nativo XP
+
+> **Mejor con MCP.** Karajan Code esta disenado para usarse como servidor MCP dentro de tu agente de IA (Claude, Codex, etc.). El agente envia tareas a `kj_run`, recibe notificaciones de progreso en tiempo real, y obtiene resultados estructurados. Sin copiar y pegar.
 
 ## Requisitos
 
 - **Node.js** >= 18
-- **Docker** — necesario para el analisis estatico con SonarQube. Si no tienes Docker o no necesitas SonarQube, desactivalo con `--no-sonar` o `sonarqube.enabled: false` en la config
+- **Docker** (necesario para SonarQube). Si no lo necesitas, desactivalo con `--no-sonar` o `sonarqube.enabled: false`
 - Al menos un agente de IA instalado: Claude, Codex, Gemini o Aider
 
 ## Pipeline
@@ -66,7 +67,7 @@ triage? ─> researcher? ─> planner? ─> coder ─> refactorer? ─> sonar?
 
 | Rol | Descripcion | Por defecto |
 |-----|-------------|-------------|
-| **triage** | Director de pipeline — analiza la complejidad y activa roles dinamicamente | **On** |
+| **triage** | Director de pipeline: analiza la complejidad y activa roles dinamicamente | **On** |
 | **researcher** | Investiga el contexto del codebase antes de planificar | Off |
 | **planner** | Genera planes de implementacion estructurados | Off |
 | **coder** | Escribe codigo y tests siguiendo metodologia TDD | **Siempre activo** |
@@ -75,7 +76,7 @@ triage? ─> researcher? ─> planner? ─> coder ─> refactorer? ─> sonar?
 | **reviewer** | Revision de codigo con perfiles de exigencia configurables | **Siempre activo** |
 | **tester** | Quality gate de tests y verificacion de cobertura | **On** |
 | **security** | Auditoria de seguridad OWASP | **On** |
-| **solomon** | Supervisor de sesion — monitoriza salud de iteraciones con 5 reglas (incl. reviewer overreach), media reviews estancados, escala ante anomalias | **On** |
+| **solomon** | Supervisor de sesion: monitoriza salud de iteraciones con 5 reglas (incl. reviewer overreach), media reviews estancados, escala ante anomalias | **On** |
 | **commiter** | Automatizacion de git commit, push y PR tras aprobacion | Off |
 
 Los roles marcados con `?` son opcionales y se pueden activar por ejecucion o via config.
@@ -129,33 +130,135 @@ Guias completas: [`docs/multi-instance.md`](multi-instance.md) | [`docs/install-
 
 `kj init` auto-detecta los agentes instalados. Si solo hay uno disponible, se asigna a todos los roles automaticamente.
 
-## Inicio rapido
+## Tres formas de usar Karajan
+
+Karajan instala **tres comandos**: `kj`, `kj-tail` y `karajan-mcp`.
+
+### 1. CLI: directamente desde terminal
 
 ```bash
-# Ejecutar una tarea con defaults (claude=coder, codex=reviewer, TDD)
 kj run "Implementar autenticacion de usuario con JWT"
-
-# Solo coder (sin revision)
 kj code "Anadir validacion de inputs al formulario de registro"
-
-# Solo reviewer (revisar diff actual)
 kj review "Revisar los cambios de autenticacion"
+kj plan "Refactorizar la capa de base de datos"
+```
 
-# Generar un plan de implementacion
-kj plan "Refactorizar la capa de base de datos para usar connection pooling"
+### 2. MCP: dentro de tu agente de IA
 
-# Pipeline completo con todas las opciones
-kj run "Corregir inyeccion SQL critica en el endpoint de busqueda" \
-  --coder claude \
-  --reviewer codex \
-  --reviewer-fallback claude \
-  --methodology tdd \
-  --enable-triage \
-  --enable-tester \
-  --enable-security \
-  --auto-commit \
-  --auto-push \
-  --max-iterations 5
+El caso de uso principal. Karajan corre como servidor MCP dentro de Claude Code, Codex o Gemini. El agente tiene acceso a 20 herramientas (`kj_run`, `kj_code`, `kj_review`, etc.) y delega el trabajo pesado al pipeline de Karajan.
+
+```
+Tu → Claude Code → kj_run (via MCP) → triage → coder → sonar → reviewer → tester → security
+```
+
+**El problema**: cuando Karajan corre dentro de un agente de IA, pierdes visibilidad. El agente te muestra el resultado final, pero no las etapas del pipeline, iteraciones o decisiones de Solomon en tiempo real.
+
+### 3. kj-tail: monitorizar desde otro terminal
+
+**La herramienta companera.** Abre un segundo terminal en el **mismo directorio del proyecto** donde esta trabajando tu agente de IA:
+
+```bash
+kj-tail
+```
+
+Veras la salida del pipeline en vivo (etapas, resultados, iteraciones, errores) tal como ocurren.
+
+```bash
+kj-tail                  # Seguir pipeline en tiempo real (por defecto)
+kj-tail -v               # Verbose: incluir heartbeats de agente y presupuesto
+kj-tail -t               # Mostrar timestamps
+kj-tail -s               # Snapshot: mostrar log actual y salir
+kj-tail -n 50            # Mostrar ultimas 50 lineas y seguir
+kj-tail --help           # Todas las opciones
+```
+
+> **Importante**: `kj-tail` debe ejecutarse desde el mismo directorio donde el agente de IA esta trabajando. Lee `<proyecto>/.kj/run.log`, que se crea cuando Karajan arranca un pipeline via MCP.
+
+**Flujo tipico:**
+
+```
+┌──────────────────────────┐    ┌──────────────────────────┐
+│  Terminal 1               │    │  Terminal 2               │
+│                           │    │                           │
+│  $ claude                 │    │  $ kj-tail                │
+│  > implementa la          │    │                           │
+│    siguiente tarea        │    │  ├─ 📋 Triage: medium     │
+│    prioritaria            │    │  ├─ 🔬 Researcher ✅      │
+│                           │    │  ├─ 🧠 Planner ✅         │
+│  (Claude llama a kj_run   │    │  ├─ 🔨 Coder ✅           │
+│   via MCP, solo ves       │    │  ├─ 🔍 Sonar: OK         │
+│   el resultado final)     │    │  ├─ 👁️ Reviewer ❌        │
+│                           │    │  ├─ ⚖️ Solomon: 2 cond.   │
+│                           │    │  ├─ 🔨 Coder (iter 2) ✅  │
+│                           │    │  ├─ ✅ Review: APPROVED    │
+│                           │    │  ├─ 🧪 Tester: passed     │
+│                           │    │  └─ 🏁 Result: APPROVED   │
+└──────────────────────────┘    └──────────────────────────┘
+```
+
+**Ejemplo con pipeline completo**, tarea compleja con todos los roles:
+
+```
+┌─ Terminal 1 ─────────────────────────────────────────────────────────────────┐
+│                                                                              │
+│  $ claude                                                                    │
+│                                                                              │
+│  > Construye una API REST para un sistema de reservas. Requisitos:           │
+│  > - Express + TypeScript con validacion Zod en cada endpoint                │
+│  > - Endpoints: POST /bookings, GET /bookings/:id,                           │
+│  >   PATCH /bookings/:id/cancel                                              │
+│  > - Una reserva tiene: id, guestName, roomType (standard|suite|penthouse),  │
+│  >   checkIn, checkOut, status (confirmed|cancelled)                         │
+│  > - Validar: checkOut posterior a checkIn, sin fechas pasadas,              │
+│  >   roomType debe ser un valor valido del enum                              │
+│  > - Cancelar devuelve 409 si ya esta cancelada                              │
+│  > - Usa TDD. Ejecutalo con Karajan con architect y planner activos,         │
+│  >   modo paranoid. Coder claude, reviewer codex.                            │
+│                                                                              │
+│  Claude llama a kj_run via MCP con:                                          │
+│    --enable-architect --enable-researcher --enable-planner --mode paranoid    │
+│                                                                              │
+└──────────────────────────────────────────────────────────────────────────────┘
+
+┌─ Terminal 2: kj-tail ────────────────────────────────────────────────────────┐
+│                                                                              │
+│  kj-tail v1.37.0 — .kj/run.log                                              │
+│                                                                              │
+│  ├─ 📋 Triage: medium (sw) — activando researcher, architect, planner        │
+│  ├─ ⚙️ Preflight passed — all checks OK                                     │
+│  ├─ 🔬 Researcher: 8 ficheros, 3 patrones, 5 restricciones                  │
+│  ├─ 🏗️ Architect: diseno 3 capas (routes → service → validators)            │
+│  ├─ 🧠 Planner: 6 pasos — tests primero, luego rutas, servicio, validadores │
+│  │                                                                           │
+│  ▶ Iteracion 1/5                                                             │
+│  ├─ 🔨 Coder (claude): 3 endpoints + 18 tests                               │
+│  ├─ 📋 TDD: PASS (3 src, 2 test)                                            │
+│  ├─ 🔍 Sonar: Quality gate OK                                               │
+│  ├─ 👁️ Reviewer (codex): REJECTED (2 blocking)                              │
+│  │   "Falta 404 para GET booking inexistente"                                │
+│  │   "Endpoint cancel sin test de idempotencia"                              │
+│  ├─ ⚖️ Solomon: approve_with_conditions (2 condiciones)                     │
+│  │   "Anadir respuesta 404 y test para GET /bookings/:id con id desconocido" │
+│  │   "Anadir test: cancelar reserva ya cancelada devuelve 409, no 500"       │
+│  │                                                                           │
+│  ▶ Iteracion 2/5                                                             │
+│  ├─ 🔨 Coder (claude): corregido — 22 tests                                 │
+│  ├─ 📋 TDD: PASS                                                            │
+│  ├─ 🔍 Sonar: OK                                                            │
+│  ├─ 👁️ Reviewer (codex): APPROVED                                           │
+│  ├─ 🧪 Tester: passed — cobertura 94%, 22 tests                             │
+│  ├─ 🔒 Security: passed — 0 criticos, 1 bajo (helmet recomendado)           │
+│  ├─ 📊 Audit: CERTIFIED (3 advertencias)                                    │
+│  │                                                                           │
+│  🏁 Resultado: APPROVED                                                      │
+│     🔬 Investigacion: 8 ficheros, 3 patrones                                 │
+│     🗺 Plan: 6 pasos (tests primero)                                         │
+│     🧪 Cobertura: 94%, 22 tests                                              │
+│     🔒 Seguridad: OK                                                         │
+│     🔍 Sonar: OK                                                             │
+│     💰 Presupuesto: $0.42 (claude: $0.38, codex: $0.04)                      │
+│                                                                              │
+└──────────────────────────────────────────────────────────────────────────────┘
 ```
 
 ## Comandos CLI
@@ -230,7 +333,7 @@ Cada rol tiene un template `.md` con instrucciones que el agente de IA sigue. Lo
 
 Usa `kj roles show <rol>` para inspeccionar cualquier template. Crea un override de proyecto para personalizar el comportamiento por proyecto.
 
-**Variantes de revision**: `reviewer-strict`, `reviewer-relaxed`, `reviewer-paranoid` — seleccionables via flag `--mode` o config `review_mode`.
+**Variantes de revision**: `reviewer-strict`, `reviewer-relaxed`, `reviewer-paranoid`, seleccionables via flag `--mode` o config `review_mode`.
 
 ## Contribuir
 
@@ -238,7 +341,7 @@ Usa `kj roles show <rol>` para inspeccionar cualquier template. Crea un override
 git clone https://github.com/manufosela/karajan-code.git
 cd karajan-code
 npm install
-npm test              # Ejecutar 1040+ tests con Vitest
+npm test              # Ejecutar 2044 tests con Vitest
 npm run test:watch    # Modo watch
 npm run validate      # Lint + test
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "karajan-code",
-  "version": "1.36.0",
+  "version": "1.37.0",
   "description": "Local multi-agent coding orchestrator with TDD, SonarQube, and code review pipeline",
   "type": "module",
   "license": "AGPL-3.0",
@@ -38,6 +38,7 @@
   ],
   "bin": {
     "kj": "bin/kj.js",
+    "kj-tail": "bin/kj-tail",
     "karajan-mcp": "bin/karajan-mcp.js"
   },
   "scripts": {

package/src/orchestrator/iteration-stages.js

@@ -21,7 +21,7 @@ export async function runCoderStage({ coderRoleInstance, coderRole, config, logg
     emitter,
     makeEvent("coder:start", { ...eventBase, stage: "coder" }, {
       message: `Coder (${coderRole.provider}) running`,
-      detail: { coder: coderRole.provider }
+      detail: { coder: coderRole.provider, provider: coderRole.provider, executorType: "agent" }
     })
   );
 
@@ -89,7 +89,8 @@ export async function runCoderStage({ coderRoleInstance, coderRole, config, logg
           emitProgress(
             emitter,
             makeEvent("coder:end", { ...eventBase, stage: "coder" }, {
-              message: `Coder completed (fallback: ${fallbackCoder})`
+              message: `Coder completed (fallback: ${fallbackCoder})`,
+              detail: { provider: fallbackCoder, executorType: "agent" }
             })
           );
           return;
@@ -114,7 +115,8 @@ export async function runCoderStage({ coderRoleInstance, coderRole, config, logg
       emitter,
       makeEvent("coder:end", { ...eventBase, stage: "coder" }, {
         status: "fail",
-        message: `Coder failed: ${details}`
+        message: `Coder failed: ${details}`,
+        detail: { provider: coderRole.provider, executorType: "agent" }
       })
     );
     throw new Error(`Coder failed: ${details}`);
@@ -124,7 +126,8 @@ export async function runCoderStage({ coderRoleInstance, coderRole, config, logg
   emitProgress(
     emitter,
     makeEvent("coder:end", { ...eventBase, stage: "coder" }, {
-      message: "Coder completed"
+      message: "Coder completed",
+      detail: { provider: coderRole.provider, executorType: "agent" }
     })
   );
 }
@@ -135,7 +138,7 @@ export async function runRefactorerStage({ refactorerRole, config, logger, emitt
     emitter,
     makeEvent("refactorer:start", { ...eventBase, stage: "refactorer" }, {
       message: `Refactorer (${refactorerRole.provider}) running`,
-      detail: { refactorer: refactorerRole.provider }
+      detail: { refactorer: refactorerRole.provider, provider: refactorerRole.provider, executorType: "agent" }
     })
   );
   const refactorerOnOutput = ({ stream, line }) => {
@@ -184,7 +187,8 @@ export async function runRefactorerStage({ refactorerRole, config, logger, emitt
       emitter,
       makeEvent("refactorer:end", { ...eventBase, stage: "refactorer" }, {
         status: "fail",
-        message: `Refactorer failed: ${details}`
+        message: `Refactorer failed: ${details}`,
+        detail: { provider: refactorerRole.provider, executorType: "agent" }
       })
     );
     throw new Error(`Refactorer failed: ${details}`);
@@ -193,7 +197,8 @@ export async function runRefactorerStage({ refactorerRole, config, logger, emitt
   emitProgress(
     emitter,
     makeEvent("refactorer:end", { ...eventBase, stage: "refactorer" }, {
-      message: "Refactorer completed"
+      message: "Refactorer completed",
+      detail: { provider: refactorerRole.provider, executorType: "agent" }
     })
   );
 }
@@ -287,7 +292,8 @@ export async function runTddCheckStage({ config, logger, emitter, eventBase, ses
         ok: tddEval.ok,
         reason: tddEval.reason,
         sourceFiles: tddEval.sourceFiles?.length || 0,
-        testFiles: tddEval.testFiles?.length || 0
+        testFiles: tddEval.testFiles?.length || 0,
+        executorType: "local"
       }
     })
   );
@@ -386,7 +392,8 @@ export async function runSonarStage({ config, logger, emitter, eventBase, sessio
   emitProgress(
     emitter,
     makeEvent("sonar:start", { ...eventBase, stage: "sonar" }, {
-      message: "SonarQube scanning"
+      message: "SonarQube scanning",
+      detail: { provider: "sonarqube", executorType: "local" }
     })
   );
 
@@ -470,7 +477,7 @@ export async function runSonarStage({ config, logger, emitter, eventBase, sessio
     makeEvent("sonar:end", { ...eventBase, stage: "sonar" }, {
       status: sonarResult.blocking ? "fail" : "ok",
       message: `Quality gate: ${sonarResult.gateStatus}`,
-      detail: { projectKey: sonarResult.projectKey, gateStatus: sonarResult.gateStatus, openIssues: sonarResult.openIssuesTotal }
+      detail: { projectKey: sonarResult.projectKey, gateStatus: sonarResult.gateStatus, openIssues: sonarResult.openIssuesTotal, provider: "sonarqube", executorType: "local" }
     })
   );
 
@@ -498,7 +505,8 @@ export async function runSonarCloudStage({ config, logger, emitter, eventBase, s
   emitProgress(
     emitter,
     makeEvent("sonarcloud:start", { ...eventBase, stage: "sonarcloud" }, {
-      message: "SonarCloud scanning"
+      message: "SonarCloud scanning",
+      detail: { provider: "sonarcloud", executorType: "local" }
     })
   );
 
@@ -532,7 +540,7 @@ export async function runSonarCloudStage({ config, logger, emitter, eventBase, s
     makeEvent("sonarcloud:end", { ...eventBase, stage: "sonarcloud" }, {
       status,
       message,
-      detail: { projectKey: result.projectKey, exitCode: result.exitCode }
+      detail: { projectKey: result.projectKey, exitCode: result.exitCode, provider: "sonarcloud", executorType: "local" }
     })
   );
 
@@ -681,7 +689,7 @@ export async function runReviewerStage({ reviewerRole, config, logger, emitter,
     emitter,
     makeEvent("reviewer:start", { ...eventBase, stage: "reviewer" }, {
       message: `Reviewer (${reviewerRole.provider}) running`,
-      detail: { reviewer: reviewerRole.provider }
+      detail: { reviewer: reviewerRole.provider, provider: reviewerRole.provider, executorType: "agent" }
     })
   );
 
@@ -692,6 +700,30 @@ export async function runReviewerStage({ reviewerRole, config, logger, emitter,
     logger.warn(`Review diff generation failed: ${err.message}`);
     return { approved: false, blocking_issues: [{ description: `Diff generation failed: ${err.message}` }], non_blocking_suggestions: [], summary: `Reviewer failed: cannot generate diff — ${err.message}`, confidence: 0 };
   }
+
+  // Injection guard: scan diff before sending to AI reviewer
+  const { scanDiff } = await import("../utils/injection-guard.js");
+  const guardResult = scanDiff(diff);
+  if (!guardResult.clean) {
+    logger.warn(`Injection guard: ${guardResult.summary}`);
+    emitProgress(emitter, makeEvent("guard:injection", { ...eventBase, stage: "reviewer" }, {
+      message: `Injection guard blocked review: ${guardResult.summary}`,
+      detail: { findings: guardResult.findings, summary: guardResult.summary }
+    }));
+    return {
+      approved: false,
+      blocking_issues: guardResult.findings.map((f) => ({
+        id: `INJECTION_${f.type.toUpperCase()}`,
+        severity: "critical",
+        description: `Potential prompt injection (${f.type}): ${f.snippet}`,
+        line: f.line,
+      })),
+      non_blocking_suggestions: [],
+      summary: `Review blocked by injection guard: ${guardResult.summary}`,
+      confidence: 1,
+    };
+  }
+
   const reviewerOnOutput = ({ stream, line }) => {
     emitProgress(emitter, makeEvent("agent:output", { ...eventBase, stage: "reviewer" }, {
       message: line,
@@ -754,7 +786,8 @@ export async function runReviewerStage({ reviewerRole, config, logger, emitter,
       emitter,
       makeEvent("reviewer:end", { ...eventBase, stage: "reviewer" }, {
         status: "fail",
-        message: `Reviewer failed: ${details}`
+        message: `Reviewer failed: ${details}`,
+        detail: { provider: reviewerRole.provider, executorType: "agent" }
       })
     );
     throw new Error(`Reviewer failed: ${details}`);
@@ -836,7 +869,9 @@ export async function runReviewerStage({ reviewerRole, config, logger, emitter,
         blockingCount: review.blocking_issues.length,
         issues: review.blocking_issues.map(
           (x) => `${x.id || "ISSUE"}: ${x.description || "Missing description"}`
-        )
+        ),
+        provider: reviewerRole.provider,
+        executorType: "agent"
       }
     })
   );

package/src/orchestrator/post-loop-stages.js

@@ -98,7 +98,8 @@ export async function runTesterStage({ config, logger, emitter, eventBase, sessi
   emitProgress(
     emitter,
     makeEvent("tester:start", { ...eventBase, stage: "tester" }, {
-      message: "Tester evaluating test quality"
+      message: "Tester evaluating test quality",
+      detail: { provider: config?.roles?.tester?.provider || config?.roles?.coder?.provider || config?.coder || "claude", executorType: "agent" }
     })
   );
 
@@ -126,11 +127,13 @@ export async function runTesterStage({ config, logger, emitter, eventBase, sessi
     attempts: attempts.length > 1 ? attempts : undefined
   });
 
+  const testerProvider = provider || coderRole.provider;
   emitProgress(
     emitter,
     makeEvent("tester:end", { ...eventBase, stage: "tester" }, {
       status: testerOutput.ok ? "ok" : "fail",
-      message: testerOutput.ok ? "Tester passed" : `Tester: ${testerOutput.summary}`
+      message: testerOutput.ok ? "Tester passed" : `Tester: ${testerOutput.summary}`,
+      detail: { ok: testerOutput.ok, summary: testerOutput.summary, provider: testerProvider, executorType: "agent" }
     })
   );
 
@@ -143,7 +146,7 @@ export async function runTesterStage({ config, logger, emitter, eventBase, sessi
       makeEvent("tester:auto-continue", { ...eventBase, stage: "tester" }, {
         status: "warn",
         message: `Tester issues are advisory (reviewer approved), continuing: ${testerOutput.summary}`,
-        detail: { summary: testerOutput.summary, auto_continued: true }
+        detail: { summary: testerOutput.summary, auto_continued: true, provider: testerProvider, executorType: "agent" }
       })
     );
     return { action: "ok", stageResult: { ok: false, summary: testerOutput.summary || "Tester issues (advisory)", auto_continued: true } };
@@ -158,7 +161,8 @@ export async function runSecurityStage({ config, logger, emitter, eventBase, ses
   emitProgress(
     emitter,
     makeEvent("security:start", { ...eventBase, stage: "security" }, {
-      message: "Security auditing code"
+      message: "Security auditing code",
+      detail: { provider: config?.roles?.security?.provider || config?.roles?.coder?.provider || config?.coder || "claude", executorType: "agent" }
     })
   );
 
@@ -186,11 +190,13 @@ export async function runSecurityStage({ config, logger, emitter, eventBase, ses
     attempts: attempts.length > 1 ? attempts : undefined
   });
 
+  const securityProvider = provider || coderRole.provider;
   emitProgress(
     emitter,
     makeEvent("security:end", { ...eventBase, stage: "security" }, {
       status: securityOutput.ok ? "ok" : "fail",
-      message: securityOutput.ok ? "Security audit passed" : `Security: ${securityOutput.summary}`
+      message: securityOutput.ok ? "Security audit passed" : `Security: ${securityOutput.summary}`,
+      detail: { ok: securityOutput.ok, summary: securityOutput.summary, provider: securityProvider, executorType: "agent" }
     })
   );
 
@@ -246,7 +252,8 @@ export async function runImpeccableStage({ config, logger, emitter, eventBase, s
   emitProgress(
     emitter,
     makeEvent("impeccable:start", { ...eventBase, stage: "impeccable" }, {
-      message: "Impeccable auditing frontend design quality"
+      message: "Impeccable auditing frontend design quality",
+      detail: { provider: config?.roles?.impeccable?.provider || coderRole.provider, executorType: "agent" }
     })
   );
 
@@ -277,13 +284,15 @@ export async function runImpeccableStage({ config, logger, emitter, eventBase, s
   });
 
   const verdict = impeccableOutput.result?.verdict || "APPROVED";
+  const impeccableProvider = config?.roles?.impeccable?.provider || coderRole.provider;
   emitProgress(
     emitter,
     makeEvent("impeccable:end", { ...eventBase, stage: "impeccable" }, {
       status: impeccableOutput.ok ? "ok" : "fail",
       message: impeccableOutput.ok
         ? (verdict === "IMPROVED" ? "Impeccable applied design fixes" : "Impeccable audit passed")
-        : `Impeccable: ${impeccableOutput.summary}`
+        : `Impeccable: ${impeccableOutput.summary}`,
+      detail: { provider: impeccableProvider, executorType: "agent" }
     })
   );
 
@@ -296,7 +305,8 @@ export async function runFinalAuditStage({ config, logger, emitter, eventBase, s
   emitProgress(
     emitter,
     makeEvent("audit:start", { ...eventBase, stage: "audit" }, {
-      message: "Final audit — verifying code quality"
+      message: "Final audit — verifying code quality",
+      detail: { provider: config?.roles?.audit?.provider || config?.roles?.coder?.provider || config?.coder || "claude", executorType: "agent" }
     })
   );
 
@@ -324,6 +334,7 @@ export async function runFinalAuditStage({ config, logger, emitter, eventBase, s
     attempts: attempts.length > 1 ? attempts : undefined
   });
 
+  const auditProvider = provider || coderRole.provider;
   if (!auditOutput.ok) {
     // Audit agent failed to run — treat as advisory, don't block pipeline
     logger.warn(`Audit agent error (advisory): ${auditOutput.summary}`);
@@ -331,7 +342,8 @@ export async function runFinalAuditStage({ config, logger, emitter, eventBase, s
       emitter,
       makeEvent("audit:end", { ...eventBase, stage: "audit" }, {
         status: "warn",
-        message: `Audit: agent error (advisory), continuing — ${auditOutput.summary}`
+        message: `Audit: agent error (advisory), continuing — ${auditOutput.summary}`,
+        detail: { provider: auditProvider, executorType: "agent" }
       })
     );
     return { action: "ok", stageResult: { ok: false, summary: auditOutput.summary || "Audit agent error (advisory)", auto_continued: true } };
@@ -374,7 +386,8 @@ export async function runFinalAuditStage({ config, logger, emitter, eventBase, s
       emitter,
       makeEvent("audit:end", { ...eventBase, stage: "audit" }, {
         status: "fail",
-        message: `Audit: ${criticalCount + highCount} issue(s) found, sending back to coder`
+        message: `Audit: ${criticalCount + highCount} issue(s) found, sending back to coder`,
+        detail: { provider: auditProvider, executorType: "agent" }
       })
     );
 
@@ -392,7 +405,8 @@ export async function runFinalAuditStage({ config, logger, emitter, eventBase, s
     emitter,
     makeEvent("audit:end", { ...eventBase, stage: "audit" }, {
       status: "ok",
-      message: certifiedMsg
+      message: certifiedMsg,
+      detail: { provider: auditProvider, executorType: "agent" }
     })
   );