@johpaz/hive-sdk 0.4.9 → 0.5.1

package/CHANGELOG.md

@@ -1,6 +1,90 @@
 # Changelog
 
-## Sin publicar
+## 0.5.1
+
+### Seguridad — claves aisladas por inquilino
+
+- **Secretos filtrados entre inquilinos por la caché en memoria.** El
+  almacén de secretos cacheaba cada valor descifrado en un `Map` del proceso
+  indexado sólo por nombre (`provider:openai:api_key`), y el llavero del SO
+  también es de toda la máquina. La colección `secrets` sí está particionada,
+  pero la caché la tapaba: después de que un inquilino leyera o guardara su
+  clave, `loadProviderApiKey` le devolvía esa misma clave a cualquier otro
+  inquilino del proceso, y `resolveProviderConfig` la usaba para cobrarle a
+  la cuenta equivocada cuando la llamada no traía `credentials`. Ahora la
+  caché se indexa por inquilino y, con un inquilino activo, el llavero del SO
+  no se lee, no se escribe ni se borra. Sin inquilino (escritorio) todo sigue
+  igual.
+- **La clave del entorno ya no se usa en nombre de un inquilino.** Con un
+  inquilino activo y sin `credentials` ni clave guardada, `resolveProviderConfig`
+  caía en `<PROVEEDOR>_API_KEY` del proceso, que es la cuenta de la plataforma;
+  lo mismo OCR (`vision-service`), voz (STT/TTS), `computer_use` y Jev. Ahora
+  todos pasan por `envSecret(nombre)`, que dentro de un inquilino devuelve
+  `undefined`. Los adaptadores de Anthropic, Gemini y Gemini Live pasan siempre
+  una cadena al SDK del proveedor, porque con `undefined` esos SDK leían la
+  variable de entorno por su cuenta. **Cambio de comportamiento:** un host
+  multi-inquilino que dependía de ese respaldo tiene que pasar la clave en
+  `credentials` o guardarla en los secretos del inquilino; sin eso la llamada
+  falla por falta de clave en vez de cobrarse a la plataforma. Sin inquilino
+  (escritorio) el entorno sigue siendo el último respaldo.
+- Nuevo `envSecret(nombre)` en `@johpaz/hive-sdk/storage`: la variable de
+  entorno sólo fuera de un inquilino. Úsalo en tus propias tools en lugar de
+  `process.env.X_API_KEY`.
+- Quitado `loadDurableProviderApiKey` (interno, agregado en 0.5.0 y nunca
+  exportado por un barrel): `loadProviderApiKey` ya es seguro por inquilino.
+
+## 0.5.0
+
+### Jev — plano de decisión (OpenRouter Decisions)
+
+Portado de hive 1.1.0. Jev decide por turno qué historial, herramientas,
+skills, notas y reglas del playbook entran al contexto; entre iteraciones poda
+resultados viejos de herramientas y sugiere la siguiente acción; decide si un
+lote de herramientas corre en paralelo, y conoce el mapa del enjambre
+(especialistas y estado de cada MCP) para recomendar a quién delegar.
+**Sin clave de OpenRouter, Jev no existe y todo corre igual que antes.**
+
+- **Clave inyectable por llamada**: `jev?: { apiKey, mcpSettingsPath? } | false`
+  en `AgentLoopOptions`, `compileContext`, `IsolatedAgentOptions`,
+  `runRoleSwarm` y `runSwarm`, igual que `credentials`. `false` lo apaga;
+  sin la opción decide la fila `openrouter` del inquilino actual. Con un
+  inquilino activo **nunca** se usa `OPENROUTER_API_KEY` ni la caché de
+  secretos del proceso: la clave de la plataforma no se usa en nombre de un
+  cliente.
+- **Estado por inquilino**: fallos, cooldown y totales se llevan por
+  `currentTenant()`; una clave inválida de un cliente no pone en fallback a
+  los demás.
+- **Evento para el host**: cada decisión llega por `onStep` como
+  `StepEvent` `jev_decision` (`jev`: agente, tipo, resumen, tokens ahorrados,
+  latencia, costo, especialista recomendado, MCP apagados). También se emite
+  `canvas:jev_decision` / `canvas:jev_status` para hosts tipo hive.
+- **Uso y costo**: `recordJevDecision` y los campos `jev*` de
+  `UsageRollupDoc`; `getUsageStats()` devuelve `jev` con el total y el
+  desglose por agente. El ahorro se estima (caracteres/4) y se cotiza con el
+  modelo del agente asesorado.
+- **Catálogo**: modelo `openrouter/typesafe/jev-1.13` con `modelType:
+  "decision"`, excluido de `get_available_models` (y de `getDefaultLLM`, que
+  sólo toma modelos `llm`).
+- Herramienta nueva `conversation_read`: recupera mensajes o notas que Jev
+  dejó fuera del contexto, siempre dentro del hilo actual.
+- `executeToolBatch` acepta `parallelToolCalls` por lote.
+- `NarrationEventDoc.kind` suma `"decision"`: un host puede anotar las
+  decisiones de Jev en `narrationEvents` para sus vistas de actividad.
+  `shouldDeliverToChannel` nunca lo entrega a un canal.
+- `loadDurableProviderApiKey(id)`: lee la clave sólo de la colección
+  `secrets` (particionada por inquilino), sin pasar por la caché de proceso ni
+  el llavero del SO.
+
+**Privacidad.** Con Jev activo se envían a la API de decisiones de OpenRouter
+(`https://openrouter.ai/api/alpha/decisions`), con la clave del workspace:
+el objetivo del turno (hasta 3 500 caracteres), extractos de hasta 450
+caracteres de mensajes previos del hilo, nombre y descripción de herramientas
+y skills candidatas, notas del scratchpad y reglas del playbook (hasta 350
+caracteres cada una), extractos de resultados de herramientas (hasta 650
+caracteres), argumentos de llamadas en lote (hasta 700) y el mapa del enjambre
+(ids, nombres y descripciones de especialistas, nombres y estado de los MCP).
+No se envían ids de MCP con prefijo de inquilino, credenciales ni adjuntos
+binarios. Un host que no quiera enviar nada pasa `jev: false`.
 
 ### Plataforma y seguridad
 

package/README.md

@@ -25,6 +25,8 @@ bun add @johpaz/hive-sdk
 - **Runtime**: ejecución paralela de tools vía Bun Workers.
 - **Gateway**: servidor HTTP/WebSocket para exponer agentes como API.
 - **Memoria y estado**: HiveDB (colecciones + índice BM25), scratchpad, context compiler con compactación.
+- **Jev (opcional)**: plano de decisión sobre la API Decisions de OpenRouter. Por turno elige qué historial, tools, skills, notas y reglas entran al contexto, poda resultados viejos entre iteraciones y decide si un lote de tools corre en paralelo. Sin clave de OpenRouter no existe y todo corre igual. Ver [API-AGENTS.md](./docs/API-AGENTS.md#jev-plano-de-decisión).
+- **Multi-inquilino**: varios enjambres en una sola HiveDB con `runInTenant`; credenciales y clave de Jev por llamada (`credentials`, `jev`), sin que la clave de un inquilino ni la de la plataforma se usen en nombre de otro.
 - **Servicios**: CRUD tipado de agentes, enjambres, skills, modelos, MCP y cron para montarle **la interfaz que quieras** — móvil, web o escritorio. Ver [API-SERVICES.md](./docs/API-SERVICES.md).
 - **Sesiones**: un hilo por canal y por contacto, con historial, resumen y reanudación tras un corte.
 - **Imágenes**: redimensionar y convertir con `Bun.Image`, sin dependencias nativas. Las imágenes entrantes se normalizan antes de llegar al modelo — una foto de cámara pasa de 217 KB a 4 KB.
@@ -197,7 +199,10 @@ capturar. El SDK lo resuelve con `resolvePort`: avisa y sigue con el default.
 
 La API key de cada provider se guarda cifrada en la base. Como alternativa, el
 SDK cae a `<PROVIDER>_API_KEY` del entorno, en mayúsculas y con el id del
-provider tal cual:
+provider tal cual. **Sólo sin inquilino** (app de escritorio, un proceso por
+instalación): dentro de `runInTenant` el entorno es de la plataforma, no del
+cliente, y no se usa nunca — la clave llega en `credentials` o desde los
+secretos del inquilino. Ver [UPGRADING.md](./docs/UPGRADING.md#051-claves-aisladas-por-inquilino).
 
 ```bash
 OPENAI_API_KEY=sk-...
@@ -205,7 +210,7 @@ ANTHROPIC_API_KEY=sk-ant-...
 GOOGLE_API_KEY=...            # provider "gemini"
 MODELSCOPE_API_KEY=ms-...
 NVIDIA_API_KEY=nvapi-...
-OPENROUTER_API_KEY=sk-or-...
+OPENROUTER_API_KEY=sk-or-...  # también activa Jev (con el provider openrouter habilitado)
 ```
 
 ## Tests
@@ -260,7 +265,7 @@ npm view @johpaz/hive-sdk dist-tags   # verificar después del release
 
 | Documento | Descripción |
 |-----------|-------------|
-| [API-AGENTS.md](docs/API-AGENTS.md) | createAgent, AgentLoop, Tool/Skill Selector, los 16 LLM Providers |
+| [API-AGENTS.md](docs/API-AGENTS.md) | createAgent, AgentLoop, Tool/Skill Selector, los 16 LLM Providers, multi-inquilino y Jev |
 | [API-CONTEXT-COMPILER.md](docs/API-CONTEXT-COMPILER.md) | Context Compiler, historial, Scratchpad, EthicsGuard, ACE |
 | [API-TOOLS-SKILLS-CHANNELS.md](docs/API-TOOLS-SKILLS-CHANNELS.md) | Tools, Skills, MCP, Gateway, Channels, Tool Runtime, Storage |
 | [API-DAG-SCHEDULER.md](docs/API-DAG-SCHEDULER.md) | DAGScheduler, TaskGraph, TaskNode, estrategias, presets |
@@ -271,4 +276,4 @@ npm view @johpaz/hive-sdk dist-tags   # verificar después del release
 
 ---
 
-*Hive SDK v0.4.9 — MIT*
+*Hive SDK v0.5.1 — MIT*

package/docs/API-AGENTS.md

@@ -7,6 +7,8 @@
 3. [Tool Selector](#tool-selector)
 4. [Skill Selector](#skill-selector)
 5. [LLM Providers](#llm-providers)
+6. [Multi-inquilino: credenciales y Jev](#multi-inquilino-credenciales-y-jev)
+7. [Jev: plano de decisión](#jev-plano-de-decisión)
 
 ---
 
@@ -240,6 +242,74 @@ const result = await runAgentIsolated({
 });
 ```
 
+### Multi-inquilino: credenciales y Jev
+
+Un host que sirve a varios clientes desde un mismo proceso corre cada turno
+dentro de `runInTenant(tenantKey, …)` y pasa las claves **por llamada**:
+
+```typescript
+import { runAgent } from "@johpaz/hive-sdk";
+import { runInTenant } from "@johpaz/hive-sdk/storage";
+
+await runInTenant(tenantKey, async () => {
+  for await (const chunk of runAgent({
+    agentId, threadId, userMessage,
+    credentials: { apiKey: claveDelModelo, baseUrl },     // gana y corta ahí
+    jev: claveOpenRouter ? { apiKey: claveOpenRouter } : false,
+    onStep: async (paso) => { /* text · tool_call · tool_result · jev_decision */ },
+  })) { /* … */ }
+});
+```
+
+Reglas con un inquilino activo (desde 0.5.1):
+
+- `credentials.apiKey` gana. Sin ella, la clave sale de los secretos **de ese
+  inquilino** (`storeProviderApiKey` dentro de su `runInTenant`).
+- Nunca se usa `<PROVIDER>_API_KEY` del entorno ni el llavero del SO: son de la
+  máquina, no del cliente. Si no hay clave, la llamada falla en vez de cobrarse
+  a la plataforma. Para tus propias tools usa `envSecret(nombre)`
+  (`@johpaz/hive-sdk/storage`), que aplica la misma regla.
+- `credentials` y `jev` se propagan a `runAgentIsolated`, `runRoleSwarm` y
+  `runSwarm`.
+
+### Jev: plano de decisión
+
+Jev hace preguntas acotadas a la API Decisions de OpenRouter
+(`typesafe/jev-1.13`) y usa las respuestas para recortar lo que recibe el
+modelo principal. **Es opcional**: sin clave no existe, no se hace ninguna
+llamada y el turno corre exactamente igual.
+
+| Momento | Qué decide |
+|---|---|
+| Al compilar el contexto | Qué mensajes previos, tools, skills, notas del scratchpad y reglas del playbook entran; a qué especialista conviene delegar, y si depende de un MCP apagado. Los últimos 4 mensajes siempre quedan. |
+| Entre iteraciones | Qué resultados viejos de tools se omiten y la siguiente acción (continuar, delegar, descubrir, cerrar). Sólo si hay ≥ 4 000 caracteres podables. |
+| Antes de ejecutar tools | Si un lote de lecturas independientes, o de delegaciones a workers distintos, corre en paralelo. |
+
+Lo omitido se puede recuperar: el prompt lista los ids y el coordinador tiene
+`conversation_read`.
+
+**Activación**, por orden:
+
+1. `jev: { apiKey, mcpSettingsPath? }` en la llamada. `mcpSettingsPath` es el
+   texto con el que el coordinador le dice al usuario dónde encender un MCP
+   (por defecto «Ajustes → Entorno → MCP Servers»).
+2. `jev: false` lo apaga.
+3. Sin la opción: el provider `openrouter` habilitado y activo, con su clave
+   guardada; sin inquilino, también `OPENROUTER_API_KEY`.
+
+**Qué ve el host.** Cada decisión llega por `onStep` como
+`{ type: "jev_decision", message, jev }`, con agente, tipo (`context`,
+`iteration`, `parallel`), resumen, tokens ahorrados estimados, latencia, costo,
+especialista recomendado y MCP apagados. También se emite
+`canvas:jev_decision`. `getUsageStats().jev` suma decisiones, costo y ahorro
+(total y por agente). Fallos y cooldown se llevan por inquilino.
+
+**Privacidad.** Se envían a OpenRouter, con la clave de la llamada, extractos
+acotados: el objetivo del turno, fragmentos de mensajes previos, nombres y
+descripciones de tools y skills, notas y reglas, fragmentos de resultados de
+tools y el mapa del enjambre (nombres, no ids con prefijo de inquilino). Nunca
+credenciales ni adjuntos. El detalle está en el [CHANGELOG](../CHANGELOG.md).
+
 ---
 
 ## Tool Selector

package/docs/INDEX.md

@@ -12,7 +12,7 @@
 | [API-RESILIENCE.md](./API-RESILIENCE.md) | Reintentos con backoff y circuit breakers |
 | [API-SESSIONS.md](./API-SESSIONS.md) | Sesiones por canal, historial, reanudación tras un corte |
 | [API-SERVICES.md](./API-SERVICES.md) | **La superficie para una UI** — CRUD de agentes, enjambres, skills, modelos, MCP, cron |
-| [API-AGENTS.md](./API-AGENTS.md) | createAgent, AgentLoop, Tool/Skill Selector, LLM Providers |
+| [API-AGENTS.md](./API-AGENTS.md) | createAgent, AgentLoop, Tool/Skill Selector, LLM Providers, multi-inquilino y Jev |
 | [API-DAG-SCHEDULER.md](./API-DAG-SCHEDULER.md) | DAGScheduler, TaskGraph, Estrategias, Presets |
 | [API-CRON.md](./API-CRON.md) | Tareas programadas: expresiones, zona horaria, misfires, motor sin dependencias |
 | [API-WORKERS-EVENTS.md](./API-WORKERS-EVENTS.md) | **Bun Workers**, createWorker, WorkerPool, AgentBus, EventBus, Canvas |
@@ -181,6 +181,10 @@ ANTHROPIC_API_KEY=sk-ant-...  # Anthropic
 LOG_LEVEL=info                # debug | info | warn | error
 ```
 
+Las `*_API_KEY` del entorno sólo se usan sin inquilino; dentro de
+`runInTenant` la clave llega en `credentials` o desde los secretos del
+inquilino (ver [UPGRADING.md](./UPGRADING.md#051-claves-aisladas-por-inquilino)).
+
 ---
 
 ## Tests

package/docs/UPGRADING.md

@@ -74,6 +74,26 @@ sigue sólo importa con el log causal encendido (`HIVE_CAUSAL_LOG=true` o
   crudo y el SDK lo califica. Los eventos que entrega traen en `agentId` la
   clave del shard; `formatCausalEvent` la muestra sin el tenant.
 
+## 0.5.1: claves aisladas por inquilino
+
+Sólo cambia algo si corres turnos dentro de `runInTenant` (un host
+multi-inquilino). Sin inquilino todo sigue igual.
+
+- **La caché de secretos y el llavero del SO ya no se comparten.** Antes, en
+  cuanto un inquilino leía o guardaba `provider:<id>:api_key`, los demás del
+  mismo proceso recibían esa clave. Ahora la caché es por inquilino y el
+  llavero no se toca dentro de un inquilino. No hay que cambiar código.
+- **El entorno ya no es respaldo dentro de un inquilino.** Si un turno no
+  trae `credentials` y el inquilino no tiene clave guardada, antes se usaba
+  `<PROVIDER>_API_KEY` del proceso (la cuenta de la plataforma); ahora la
+  llamada falla por falta de clave. Aplica al modelo principal, OCR, voz,
+  `computer_use` y Jev. Qué hacer: pasar la clave en `credentials`, o
+  guardarla con `storeProviderApiKey` dentro del `runInTenant` del cliente. Si
+  quieres que un cliente use la cuenta de la plataforma, pásala tú en
+  `credentials`, a propósito.
+- Para tus propias tools: `envSecret("MI_API_KEY")` en lugar de
+  `process.env.MI_API_KEY`.
+
 ## Compatibilidad y CI
 
 Los workflows fijan Bun 1.4.2, instalan con `--frozen-lockfile`, ejecutan el

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@johpaz/hive-sdk",
-  "version": "0.4.9",
+  "version": "0.5.1",
   "private": false,
   "description": "Hive SDK — The Agent Harness SDK. Build, deploy, and scale AI agent applications with multi-channel support, context engineering, and swarm orchestration.",
   "license": "MIT",

package/packages/core/src/agent/agent-loop.ts

@@ -23,9 +23,12 @@ import { callLLM, resolveProviderConfig, getDefaultLLM, type LLMMessage, type Pr
 import { addMessage } from "./conversation-store.ts"
 import { saveTrace, recordLLMUsage } from "./tracer.ts"
 import { maybeCompact, clearOldToolResults } from "./compaction.ts"
-import { emitCanvas } from "../canvas/emitter.ts"
+import { emitCanvas, type CanvasJevDecision } from "../canvas/emitter.ts"
 import type { MCPClientManager } from "../mcp/index.ts"
 import { compileContext } from "./context-compiler.ts"
+import { MINIMAL_TOOLS } from "./minimal-loadout.ts"
+import { jevWantsParallel, planJevIteration } from "./jev-planner.ts"
+import { emitJevDecision, type JevOption } from "./jev-decisions.ts"
 import { formatToolResult } from "../utils/toon.ts"
 import { redactBinaryStrings } from "../utils/redact-binary.ts"
 import { resolveUserId, resolveAgentId } from "../storage/onboarding.ts"
@@ -52,6 +55,10 @@ import { getNarration } from "../events/tool-narration.ts"
 
 const log = logger.child("agent-loop")
 
+const JEV_ACTION_LABELS: Record<string, string> = {
+  continue: "Continuar", delegate: "Delegar", discover: "Descubrir", finish: "Cerrar",
+}
+
 // Per-operation budget for a single LLM call — NOT an aggregate deadline for the
 // whole turn. Each call gets its own fresh window; a slow-but-healthy multi-step
 // turn (many quick operations) is never killed just for taking a while overall.
@@ -226,6 +233,12 @@ export interface AgentLoopOptions {
    * dos inquilinos concurrentes en el mismo proceso compartían credencial.
    */
   credentials?: ProviderCredentials
+  /**
+   * Jev (OpenRouter Decisions) for this run. `{ apiKey }` uses that key,
+   * `false` turns it off, undefined reads the current tenant's `openrouter`
+   * provider row. Travels with the run like `credentials`.
+   */
+  jev?: JevOption
   /** Whether to resume from a previously saved checkpoint */
   resume?: boolean
   /** Run budget — overrides agent.max_iterations when set */
@@ -258,12 +271,17 @@ export interface AgentLoopOptions {
 export type { StepEvent as AgentStepEvent }
 
 export interface StepEvent {
-  type: "text" | "tool_call" | "tool_result"
+  type: "text" | "tool_call" | "tool_result" | "jev_decision"
   message: string
   toolName?: string
   isError?: boolean
+  /** Present on `jev_decision`: what Jev decided for this run, its cost and the estimated savings. */
+  jev?: JevStepDecision
 }
 
+/** One Jev decision as the host receives it through `onStep`. */
+export type JevStepDecision = CanvasJevDecision
+
 // ─── Stream chunk types (compatible with providers/index.ts) ─────────────────
 
 export interface StreamChunk {
@@ -385,8 +403,25 @@ export async function* runAgent(
     taskContext: opts.taskContext,
     userId: opts.userId,
     causalStreamId,
+    skipJev: !!opts.resume,
+    jev: opts.jev,
   })
 
+  // Every decision goes to the canvas (hosts like hive) and to onStep (hosts
+  // that drive runAgent themselves, like hive-cloud).
+  const publishJev = async (decision: Parameters<typeof emitJevDecision>[0]): Promise<void> => {
+    const event = emitJevDecision(decision)
+    if (!opts.onStep) return
+    try {
+      await opts.onStep({ type: "jev_decision", message: event.summary, jev: event })
+    } catch (err) {
+      log.warn(`[agent-loop] onStep(jev_decision) failed: ${(err as Error).message}`)
+    }
+  }
+  if (ctx.jevDecision) {
+    await publishJev({ ...ctx.jevDecision, agentId: opts.agentId, kind: "context", provider: providerCfg.provider, model: providerCfg.model })
+  }
+
   // Force extra tools into the loadout (tests/evals)
   if (opts.extraTools?.length) {
     const existingNames = new Set(ctx.tools.map((t: any) => t.function?.name))
@@ -417,9 +452,12 @@ export async function* runAgent(
   if (opts.isolated) {
     messages.push({ role: "user", content: opts.userMessage })
   }
+  const jevObjective = typeof opts.userMessage === "string" ? opts.userMessage :
+    opts.userMessage.filter((part) => part.type === "text").map((part) => (part as { text: string }).text).join("\n")
 
   // ── Resume from checkpoint ─────────────────────────────────────────────────
-  let injectedToolNames: string[] = []
+  // Seeded with the compiled loadout so a checkpoint records the tools Jev chose.
+  let injectedToolNames: string[] = ctx.tools.map(t => t.function.name).filter(name => !MINIMAL_TOOLS.has(name))
   let systemPromptSkillSections: string[] = []
   let resumedFromPending = false
   let iterations = 0
@@ -440,6 +478,15 @@ export async function* runAgent(
       if (restored) {
         messages = restored.messages
         injectedToolNames = restored.injectedToolNames ?? []
+        // A resume skips Jev: restore the loadout the checkpoint recorded.
+        const currentTools = new Set(ctx.tools.map(t => t.function.name))
+        for (const name of injectedToolNames) {
+          const tool = ctx.allTools.find(t => t.name === name)
+          if (tool && !currentTools.has(name)) {
+            ctx.tools.push({ type: "function", function: { name: tool.name, description: tool.description, parameters: tool.parameters } })
+            currentTools.add(name)
+          }
+        }
         systemPromptSkillSections = restored.systemPromptSkillSections ?? []
         iterations = restored.iterations ?? 0
         totalInputTokens = restored.totalInputTokens ?? 0
@@ -525,11 +572,27 @@ export async function* runAgent(
       : null
     let streamedThisCall = false
     let response: Awaited<ReturnType<typeof callLLM>>
+    const jevIteration = await planJevIteration({ objective: jevObjective, messages, tools: ctx.tools, jev: opts.jev })
+      .catch((err) => { log.warn(`[agent-loop] Jev iteration fallback: ${(err as Error).message}`); return null })
+    const callMessages = jevIteration?.messages ?? messages
+    const callTools = jevIteration?.tools ?? ctx.tools
+    if (jevIteration) {
+      log.info(`[agent-loop] Jev action=${jevIteration.action} omitted_results=${jevIteration.omittedResults} tools=${callTools.map(t => t.function.name).join(",")}`)
+      // Measured on what the provider actually receives, after the usual truncation.
+      const payloadChars = (msgs: LLMMessage[], tools: typeof ctx.tools) =>
+        JSON.stringify(clearOldToolResults(msgs)).length + JSON.stringify(tools).length
+      await publishJev({
+        agentId: opts.agentId, kind: "iteration", provider: providerCfg.provider, model: providerCfg.model,
+        summary: `${JEV_ACTION_LABELS[jevIteration.action] ?? jevIteration.action} · ${jevIteration.omittedResults} resultado(s) omitido(s) · ${callTools.length}/${ctx.tools.length} herramientas`,
+        savedTokens: Math.round((payloadChars(messages, ctx.tools) - payloadChars(callMessages, callTools)) / 4),
+        latencyMs: jevIteration.decision.latencyMs, costUsd: jevIteration.decision.costUsd,
+      })
+    }
     try {
       response = await withTimeout(() => callLLM({
         ...providerCfg,
-        messages: clearOldToolResults(messages) as LLMMessage[],
-        tools: ctx.tools.length > 0 ? ctx.tools : undefined,
+        messages: clearOldToolResults(callMessages) as LLMMessage[],
+        tools: callTools.length > 0 ? callTools : undefined,
         signal: opts.signal,
         sessionId: opts.threadId,
         onToken: opts.onToken && !delegationGroupAtCall
@@ -689,6 +752,16 @@ export async function* runAgent(
       }
     }
 
+    const jevParallel = await jevWantsParallel(response.tool_calls, opts.jev)
+      .catch((err) => { log.warn(`[agent-loop] Jev parallel fallback: ${(err as Error).message}`); return null })
+    if (jevParallel?.decision) {
+      log.info(`[agent-loop] Jev parallel=${jevParallel.parallel} calls=${response.tool_calls.length}`)
+      await publishJev({
+        agentId: opts.agentId, kind: "parallel", provider: providerCfg.provider, model: providerCfg.model,
+        summary: `${response.tool_calls.length} herramientas ${jevParallel.parallel ? "en paralelo" : "en secuencia"}`,
+        savedTokens: 0, latencyMs: jevParallel.decision.latencyMs, costUsd: jevParallel.decision.costUsd,
+      })
+    }
     const toolResults = await executeToolBatch({
       toolCalls: response.tool_calls,
       allTools: ctx.allTools,
@@ -709,6 +782,7 @@ export async function* runAgent(
       },
       hiveConfig,
       workerPool: hiveConfig.tools?.workerPool,
+      parallelToolCalls: jevParallel?.parallel,
       signal: opts.signal,
     })
 
@@ -1305,6 +1379,8 @@ export interface IsolatedAgentOptions {
    * reabría justo en el camino de delegación.
    */
   credentials?: ProviderCredentials
+  /** Jev for the worker, inherited from the delegating turn like `credentials`. */
+  jev?: JevOption
 }
 
 export async function runAgentIsolatedDetailed(
@@ -1329,6 +1405,7 @@ export async function runAgentIsolatedDetailed(
     channel: opts.channel,
     sessionId: opts.sessionId,
     credentials: opts.credentials,
+    jev: opts.jev,
   })) {
     if (chunk.agent?.messages?.[0]?.content) {
       lastContent = chunk.agent.messages[0].content