@johpaz/hive-sdk 0.4.9 → 0.5.0

package/CHANGELOG.md

@@ -1,6 +1,57 @@
 # Changelog
 
-## Sin publicar
+## 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

@@ -271,4 +271,4 @@ npm view @johpaz/hive-sdk dist-tags   # verificar después del release
 
 ---
 
-*Hive SDK v0.4.9 — MIT*
+*Hive SDK v0.5.0 — MIT*

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@johpaz/hive-sdk",
-  "version": "0.4.9",
+  "version": "0.5.0",
   "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

package/packages/core/src/agent/context-compiler.ts

@@ -43,6 +43,8 @@ import { listCatalogAgents, renderAgentRoutingCatalog } from "./catalog-selector
 import { expandToolAllowlist } from "./delegation-runtime.ts"
 import { MINIMAL_TOOLS } from "./minimal-loadout.ts"
 import { normalizeMcpResult } from "./mcp-result-normalizer.ts"
+import { describeSwarmCapabilities, planJevContext, renderSpecialistLine } from "./jev-planner.ts"
+import { DEFAULT_JEV_MCP_SETTINGS_PATH, getJevKey, type JevOption } from "./jev-decisions.ts"
 
 const log = logger.child("context-compiler")
 
@@ -89,6 +91,8 @@ export interface CompiledContext {
   tools: LLMToolDef[]
   allTools: ContextTool[]
   skills: SkillDescriptor[]  // Skills loaded (minimal + discovered)
+  /** Jev's context plan, for the caller to publish once it knows the agent's resolved model. */
+  jevDecision?: { summary: string; savedTokens: number; latencyMs: number; costUsd: number; recommendedAgentId: string | null; mcpOff: string[] }
 }
 
 // ─── G9 causal context (buildAgentContext) ────────────────────────────────
@@ -166,6 +170,10 @@ export async function compileContext(opts: {
   mcpManager?: MCPClientManager | null
   /** G9 causal stream id for this invocation (agent-loop.ts's causalStreamId). */
   causalStreamId?: string
+  /** A resumed run restores the exact previously selected prompt and loadout. */
+  skipJev?: boolean
+  /** Jev for this run: a key, `false` for off, or undefined for the tenant's `openrouter` row. */
+  jev?: JevOption
 }): Promise<CompiledContext> {
   const { agentId, threadId, mcpManager, userMessage, isolated, taskContext } = opts
 
@@ -521,7 +529,52 @@ export async function compileContext(opts: {
   // En el historial las imágenes son referencias, para no reenviarlas enteras en
   // cada turno. Las de los últimos mensajes se vuelven a poner en línea: el
   // modelo todavía puede necesitar mirarlas, y una referencia no se mira.
-  const messages: LLMMessage[] = await inflateRecentImages(toAPIMessages(recentMessages))
+  let messages: LLMMessage[] = await inflateRecentImages(toAPIMessages(recentMessages))
+  let selectedSkills = allSkills
+  let jevAgentId: string | null = null
+  let jevAgentMcpOff: string[] = []
+  let omittedMessageIds: number[] = []
+  let omittedScratchpadKeys: string[] = []
+  const objectiveSource = taskContext || userMessage
+  const objective = typeof objectiveSource === "string"
+    ? objectiveSource
+    : Array.isArray(objectiveSource)
+      ? objectiveSource.filter((part) => part.type === "text").map((part) => (part as { text: string }).text).join("\n")
+      : String(objectiveSource)
+  const playbookRules = (await selectPlaybookRules(objective, userId)).filter((rule) => {
+    if (!rule.applicable_to || !rule.applicable_to.includes("agent:")) return true
+    return isCatalogAgent ? rule.applicable_to.includes(`agent:${agent.id}`) : false
+  })
+  // Without a key Jev does not exist: no swarm map, no request, the classic path below.
+  const jevEnabled = !opts.skipJev && !!await getJevKey(opts.jev).catch(() => null)
+  const swarm = jevEnabled
+    ? await describeSwarmCapabilities(effectiveMcpManager, { includeSpecialists: !isWorker })
+      .catch((err) => { log.warn(`[context-compiler] Swarm capability map failed: ${(err as Error).message}`); return undefined })
+    : undefined
+  const jevPlan = jevEnabled ? await planJevContext({
+    objective, messages, tools: toolsForLLM, allTools, skills: allSkills, scratchpadNotes, playbookRules, isWorker, swarm, jev: opts.jev,
+  }).catch((err) => { log.warn(`[context-compiler] Jev planning failed: ${(err as Error).message}`); return null }) : null
+  // Characters the classic path would have sent minus what Jev's plan sends,
+  // accumulated section by section; reported as estimated savings.
+  let jevSavedChars = 0
+  const classicToolCount = toolsForLLM.length
+  if (jevPlan) {
+    jevSavedChars += JSON.stringify(messages).length - JSON.stringify(jevPlan.messages).length
+    jevSavedChars += JSON.stringify(toolsForLLM).length
+    messages = jevPlan.messages
+    toolsForLLM = jevPlan.tools
+    selectedSkills = allSkills.filter(s => minimalSkills.some(m => m.id === s.id) || jevPlan.selectedSkillNames.includes(s.name))
+    jevAgentId = jevPlan.agentId
+    jevAgentMcpOff = jevPlan.agentMcpOff
+    omittedMessageIds = recentMessages.filter((_, i) => !jevPlan.selectedMessageIds.includes(i)).map(row => row.id)
+    omittedScratchpadKeys = scratchpadNotes.filter(note => !jevPlan.selectedScratchpadKeys.includes(note.key)).map(note => note.key)
+    if (!isWorker && (omittedMessageIds.length > 0 || omittedScratchpadKeys.length > 0) && !toolsForLLM.some(t => t.function.name === "conversation_read")) {
+      const reader = allTools.find(t => t.name === "conversation_read")
+      if (reader) toolsForLLM.push({ type: "function", function: { name: reader.name, description: reader.description, parameters: reader.parameters } })
+    }
+    jevSavedChars -= JSON.stringify(toolsForLLM).length
+    log.info(`[context-compiler] Jev selected messages=${jevPlan.selectedMessageIds.join(",")} tools=${toolsForLLM.map(t => t.function.name).join(",")} skills=${selectedSkills.map(s => s.name).join(",")} agent=${jevAgentId ?? "coordinator"}`)
+  }
 
   // [STEP-10] STRATEGY 4: ISOLATE — Build context based on agent role
   log.info(`[context-compiler] [STEP-10] Building system prompt...`)
@@ -550,33 +603,54 @@ export async function compileContext(opts: {
   // budget, so a summary appended last would be the first thing silently
   // dropped on an oversized prompt.
   systemPrompt += conversationSummarySection
+  if (omittedMessageIds.length > 0 || omittedScratchpadKeys.length > 0) {
+    const recoverable = `\n\n# CONTEXTO RECUPERABLE\nMensajes previos omitidos: ${omittedMessageIds.join(", ") || "ninguno"}. Notas omitidas: ${omittedScratchpadKeys.join(", ") || "ninguna"}. Si necesitas un dato de ellos, usa conversation_read con message_ids, note_keys o query antes de asumir que falta información.\n`
+    systemPrompt += recoverable
+    jevSavedChars -= recoverable.length
+  }
 
   // Only the live roster goes here — how to delegate, fan-out/fan-in and the
   // execution-truth rules are static doctrine and live in the coordinator's
   // stored prompt (storage/onboarding.ts), not duplicated per turn.
   if (!isWorker) {
-    const routingCatalog = renderAgentRoutingCatalog(await listCatalogAgents())
-    systemPrompt += `\n\n# COLMENA DE AGENTES\nWorkers disponibles ahora mismo (globales del sistema, ya existen):\n\n${routingCatalog}\n`
+    const catalogAgents = await listCatalogAgents()
+    const fullCatalog = `\n\n# COLMENA DE AGENTES\nWorkers disponibles ahora mismo (globales del sistema, ya existen):\n\n${renderAgentRoutingCatalog(catalogAgents)}\n`
+    if (jevPlan) {
+      // Ids, names and MCP state only: without them the coordinator spent
+      // iterations on agent_find just to learn who exists and what is
+      // connected. Descriptions stay behind agent_find.
+      const roster = swarm?.specialists.length
+        ? swarm.specialists.map(renderSpecialistLine).join("\n")
+        : catalogAgents.map(a => `- ${a.id} (${a.name})`).join("\n")
+      let rosterSection = roster ? `\n\n# COLMENA DE AGENTES\nWorkers disponibles (usa agent_find solo si necesitas su descripción). Un MCP "apagado" no está disponible; "disponible" se conecta al primer uso:\n${roster}\n` : ""
+      if (jevAgentId && jevAgentMcpOff.length > 0) {
+        // Turning a server on starts processes and uses credentials: that is
+        // the user's call, so the coordinator asks instead of delegating.
+        const settingsPath = (opts.jev && opts.jev.mcpSettingsPath) || DEFAULT_JEV_MCP_SETTINGS_PATH
+        const one = jevAgentMcpOff.length === 1
+        rosterSection += `\n\n# ESPECIALISTA RECOMENDADO — MCP APAGADO\nJev seleccionó ${jevAgentId} para esta tarea, pero depende de ${one ? "el servidor MCP" : "los servidores MCP"} ${jevAgentMcpOff.join(", ")}, que está${one ? "" : "n"} apagado${one ? "" : "s"}. No lo delegues todavía: dile al usuario que para hacerlo hace falta encender ${jevAgentMcpOff.join(", ")} en ${settingsPath} y que continúas en cuanto quede conectado. Si una parte se puede resolver sin ese MCP, ofrécela.\n`
+      } else if (jevAgentId) {
+        rosterSection += `\n\n# ESPECIALISTA RECOMENDADO\nJev seleccionó ${jevAgentId} para una subtarea acotada. Delega con task_delegate cuando puedas formular objetivo y criterios verificables.\n`
+      }
+      systemPrompt += rosterSection
+      jevSavedChars += fullCatalog.length - rosterSection.length
+    } else {
+      systemPrompt += fullCatalog
+    }
   }
 
-  const playbookInput = taskContext || userMessage
-  const playbookText = typeof playbookInput === "string"
-    ? playbookInput
-    : Array.isArray(playbookInput)
-      ? playbookInput.filter((part) => part.type === "text").map((part) => (part as any).text).join("\n")
-      : String(playbookInput)
-  const playbookRules = (await selectPlaybookRules(playbookText, userId)).filter((rule) => {
-    if (!rule.applicable_to || !rule.applicable_to.includes("agent:")) return true
-    return isCatalogAgent ? rule.applicable_to.includes(`agent:${agent.id}`) : false
-  })
-  if (playbookRules.length > 0) {
-    systemPrompt += `\n\n# PLAYBOOK APRENDIDO\n${playbookRules.map((rule) => `- ${rule.rule}`).join("\n")}\n`
+  const selectedPlaybookRules = jevPlan ? playbookRules.filter(rule => jevPlan.selectedPlaybookIds.includes(rule.id)) : playbookRules
+  for (const rule of playbookRules) if (!selectedPlaybookRules.includes(rule)) jevSavedChars += rule.rule.length + 3
+  if (selectedPlaybookRules.length > 0) {
+    systemPrompt += `\n\n# PLAYBOOK APRENDIDO\n${selectedPlaybookRules.map((rule) => `- ${rule.rule}`).join("\n")}\n`
   }
 
   // Inject scratchpad (Strategy: WRITE) — usando TOON para ahorro de tokens
-  if (scratchpadNotes.length > 0) {
+  const selectedScratchpadNotes = jevPlan ? scratchpadNotes.filter(note => jevPlan.selectedScratchpadKeys.includes(note.key)) : scratchpadNotes
+  for (const note of scratchpadNotes) if (!selectedScratchpadNotes.includes(note)) jevSavedChars += note.key.length + note.value.length + 4
+  if (selectedScratchpadNotes.length > 0) {
     const scratchpadData: Record<string, string> = {}
-    for (const n of scratchpadNotes) {
+    for (const n of selectedScratchpadNotes) {
       scratchpadData[n.key] = n.value
     }
     // TOON comprime el formato clave-valor
@@ -636,10 +710,10 @@ export async function compileContext(opts: {
 
 
     // Inject available skills (minimal + discovered)
-    if (allSkills.length > 0) {
+    if (selectedSkills.length > 0) {
       // Minimal skills: inject full body (always-loaded instructions)
       const minimalNames = new Set(minimalSkills.map(s => s.name))
-      const minimalWithBody = allSkills.filter(s => minimalNames.has(s.name) && s.body)
+      const minimalWithBody = selectedSkills.filter(s => minimalNames.has(s.name) && s.body)
       if (minimalWithBody.length > 0) {
         let minimalSection = `\n\n# SKILLS SIEMPRE ACTIVAS\n`
         for (const skill of minimalWithBody) {
@@ -649,12 +723,23 @@ export async function compileContext(opts: {
       }
 
       // Discovered skills: list only (body arrives via agent-loop when tools are injected)
-      const discoveredOnly = allSkills.filter(s => !minimalNames.has(s.name))
+      const discoveredOnly = selectedSkills.filter(s => !minimalNames.has(s.name))
+      if (jevPlan) {
+        // Classic lists every discovered skill in one line; Jev inlines the chosen bodies.
+        for (const skill of allSkills) {
+          if (minimalNames.has(skill.name)) continue
+          jevSavedChars += `- **${skill.name}**${skill.description ? ` — ${skill.description}` : ""}\n`.length
+          if (discoveredOnly.includes(skill)) jevSavedChars -= skill.body ? `\n## ${skill.name}\n${skill.body}\n`.length : 0
+        }
+      }
       if (discoveredOnly.length > 0) {
         let discoveredSection = `\n\n# SKILLS DESCUBIERTAS (relevantes para esta tarea)\n`
         for (const skill of discoveredOnly) {
-          const desc = skill.description ? ` — ${skill.description}` : ""
-          discoveredSection += `- **${skill.name}**${desc}\n`
+          if (jevPlan && skill.body) discoveredSection += `\n## ${skill.name}\n${skill.body}\n`
+          else {
+            const desc = skill.description ? ` — ${skill.description}` : ""
+            discoveredSection += `- **${skill.name}**${desc}\n`
+          }
         }
         systemPrompt += discoveredSection
       }
@@ -702,13 +787,27 @@ export async function compileContext(opts: {
     `total=${estimatedTotal}/${modelContextWindow} (${budgetPct}%)`
   )
 
+  const jevDecision = jevPlan ? {
+    summary: [
+      `${jevPlan.selectedMessageIds.length}/${recentMessages.length} mensajes`,
+      `${toolsForLLM.length}/${classicToolCount} herramientas`,
+      `${selectedSkills.length}/${allSkills.length} skills`,
+    ].join(" · "),
+    savedTokens: Math.round(jevSavedChars / 4),
+    latencyMs: jevPlan.decision.latencyMs,
+    costUsd: jevPlan.decision.costUsd,
+    recommendedAgentId: jevAgentId,
+    mcpOff: jevAgentMcpOff,
+  } : undefined
+
   return {
     systemPrompt,
     conversationSummarySection,
     messages,
     tools: toolsForLLM,
     allTools,
-    skills: allSkills,
+    skills: selectedSkills,
+    jevDecision,
   }
 }
 

package/packages/core/src/agent/index.ts

@@ -6,6 +6,8 @@ export * from "./catalog-selector.ts";
 export * from "./context-compiler.ts";
 export * from "./conversation-store.ts";
 export * from "./delegation-runtime.ts";
+export * from "./jev-decisions.ts";
+export * from "./jev-planner.ts";
 export * from "./llm-client.ts";
 export * from "./minimal-loadout.ts";
 export * from "./playbook-selector.ts";