nexakit 0.0.0-stage → 0.2.0

package/plugins/nexakit-panel/tests/register.test.ts

@@ -0,0 +1,167 @@
+import { describe, expect, test } from 'claude-code/testing';
+
+const PANE = {
+  plugin: 'nexakit-panel',
+  component: 'Pane',
+  requestId: 'panel',
+  props: { title: 'Orquesta', isFocused: false, bodyColumns: 70, placement: 'dock', scroll: { offset: 0, bodyRows: 40 }, view: {} },
+} as const;
+
+let reloj = 1_000_000;
+const drain = async (stream: any) => {
+  for await (const _ of stream) { /* el panel solo observa */ }
+  return stream.result;
+};
+
+// Lo que el motor contestaría por debajo del mod.
+function motor($: any, on: any, uso: any = { startedAt: 0, context: { window: 1000000, percent: 31 }, rateLimits: [{ kind: 'five_hour', percentUsed: 43 }, { kind: 'seven_day', percentUsed: 60 }] }, falla = false, salidaBash = '') {
+  on('command.register', () => ({ value: { command: 'panel' } }));
+  on('ui.open', () => ({ value: { isPlaced: true } }));
+  on('session.start', (_: any, e: any) => ({ cwd: e.cwd }));
+  on('clock.now', () => ({ value: (reloj += 1000) }));
+  on('session.cwd', () => ({ value: '/prueba/mi-app' }));
+  on('session.usage', () => { if (falla) throw new Error('sin datos'); return { value: uso }; });
+  on('tool.call', () => ({ result: { stdout: salidaBash, stderr: '' } }));
+  on('agent.spawn', (_: any, e: any) => ({ model: e.model ?? 'claude-haiku-5-5', agentId: `ag-${e.name ?? 'x'}` }));
+  on('turn.complete', () => ({ text: '' }));
+  on('turn.step', async function* (_: any, e: any) {
+    return { turnId: e.turnId, index: e.index, answer: '', toolUses: [], stopReason: 'end_turn', usage: null,
+      serverToolUses: e.index === 1 ? [{ id: 's1', name: 'advisor', input: {}, startedAt: 1, endedAt: 2 }]
+        : e.index === 2 ? [{ id: 's2', name: 'web_search', input: {}, startedAt: 3, endedAt: 4 }] : undefined };
+  });
+}
+const paso = ($: any, extra: any) =>
+  drain($.turn.step({ turnId: 't1', index: 0, model: 'claude-sonnet-5-5', effort: 'high', messageCount: 3, ...extra }));
+const turnoListo = ($: any, extra: any) =>
+  $.turn.complete({ reason: 'answer', answer: 'ok', durationMs: 5, isAborted: false, turnId: 't1', ...extra });
+
+describe('nexakit-panel · en la sesión', () => {
+  test('dibuja líder, subagentes, asesor, registro y límites con lo que informa el motor', async ($, on) => {
+    motor($, on);
+    await $.session.start({ surface: 'terminal', isInteractive: true, cwd: '/prueba' });
+    await paso($, {});                                              // líder: Sonnet 5.5 · high
+    await paso($, { index: 1 });                                    // el paso trae una consulta al asesor
+    await paso($, { index: 2 });                                    // otra llamada del servidor: no es el asesor
+    await $.agent.spawn({ prompt: 'mapea', name: 'search', subagentType: 'Explore', description: 'mapear el repo', model: 'claude-haiku-5-5' });
+    await $.tool.call({ tool: 'Read', file_path: 'src/auth.ts', agentId: 'ag-search' });
+    await turnoListo($, { agentId: 'ag-search' });
+
+    for (const surface of ['terminal', 'desktop'] as const) {
+      const ui = await $.ui.mount({ ...PANE, surface });
+      expect((await ui.find({ type: 'Text', text: /Sonnet 5\.5 · sesión principal/ }))?.text).toBeTruthy();
+      expect((await ui.find({ type: 'Text', text: /esfuerzo ▮▮▮▯ high/ }))?.text).toBeTruthy();
+      expect((await ui.find({ type: 'Text', text: /Asesor · consultas 1/ }))?.text).toBeTruthy();
+      expect((await ui.find({ type: 'Text', text: /search/ }))?.text).toBeTruthy();
+      expect((await ui.find({ type: 'Text', text: /Haiku 5\.5/ }))?.text).toBeTruthy();
+      expect((await ui.find({ type: 'Text', text: /✓ listo/ }))?.text).toBeTruthy();
+      expect((await ui.find({ type: 'Text', text: /Read · src\/auth\.ts/ }))?.text).toBeTruthy();
+      expect((await ui.find({ type: 'Text', text: /contexto .*31 % +5 h .*43 % +semana .*60 %/ }))?.text).toBeTruthy();
+      await ui.unmount();
+    }
+  });
+
+  test('con ancho de sobra dibuja el diagrama completo con la estructura de la imagen', async ($, on) => {
+    motor($, on);
+    await $.session.start({ surface: 'terminal', isInteractive: true, cwd: '/prueba' });
+    await paso($, {});
+    await paso($, { index: 1 });
+    await $.agent.spawn({ prompt: 'mapea', name: 'search', subagentType: 'Explore', description: 'mapear', model: 'claude-haiku-5-5' });
+    await $.agent.spawn({ prompt: 'busca', name: 'grep', subagentType: 'Explore', description: 'buscar', model: 'claude-haiku-5-5' });
+    await $.tool.call({ tool: 'Read', file_path: 'src/auth.ts', agentId: 'ag-search' });
+    await turnoListo($, { agentId: 'ag-search' });
+
+    const ui = await $.ui.mount({ ...PANE, surface: 'terminal', props: { ...PANE.props, bodyColumns: 120 } });
+    const hay = async (texto: RegExp) => expect((await ui.find({ type: 'Text', text: texto }))?.text, String(texto)).toBeTruthy();
+    for (const t of [/NEXAKIT/, /SONNET 5\.5 DIRIGE/, /HAIKU 5\.5 EN ENJAMBRE/, /═{50,}/, /sonnet 5\.5 · líder/, /ASESOR/,
+      /◆ \d\d:\d\d:\d\d consulta/, /Sonnet 5\.5 · sesión principal/, /pasos 2 · herramientas 0/, /DELEGACIÓN · subagentes/,
+      /delegar a subagentes/, /search/, /✓ listo/, /◐ corriendo/, /de vuelta en Sonnet 5\.5 · líder/, /esperando 1 subagente/,
+      /registro de sesión/, /→ src\/auth\.ts/, /claude --model sonnet/, /\[enjambre\]/, /\[consultado 1\]/, /31 %/, /43 %/, /60 %/]) {
+      await hay(t);
+    }
+    await ui.unmount();
+  });
+
+  test('en el diagrama ancho sin actividad no inventa cajas ni números', async ($, on) => {
+    motor($, on, { startedAt: 0, context: { window: 1000000 }, rateLimits: [] });
+    await $.session.start({ surface: 'terminal', isInteractive: true, cwd: '/prueba' });
+    const ui = await $.ui.mount({ ...PANE, surface: 'terminal', props: { ...PANE.props, bodyColumns: 120 } });
+    expect((await ui.find({ type: 'Text', text: /Aún no hay actividad/ }))?.text).toBeTruthy();
+    for (const falso of [/DELEGACIÓN/, /ASESOR/, /de vuelta en/, /registro de sesión/]) expect(await ui.find({ type: 'Text', text: falso })).toBeFalsy();
+    await ui.unmount();
+  });
+
+  test('con más subagentes de los que caben avisa de los que no caben y no los pierde en silencio', async ($, on) => {
+    motor($, on);
+    await $.session.start({ surface: 'terminal', isInteractive: true, cwd: '/prueba' });
+    await paso($, {});
+    for (let i = 0; i < 6; i++) await $.agent.spawn({ prompt: 'x', name: 'tarea' + i, description: 'd', model: 'claude-haiku-5-5' });
+    const ui = await $.ui.mount({ ...PANE, surface: 'terminal', props: { ...PANE.props, bodyColumns: 120 } });
+    expect((await ui.find({ type: 'Text', text: /\+3 más/ }))?.text).toBeTruthy();
+    expect((await ui.find({ type: 'Text', text: /DELEGACIÓN · subagentes/ }))?.text).toBeTruthy();
+    expect((await ui.find({ type: 'Text', text: /^ *6 *$/ }))?.text).toBeTruthy();
+    await ui.unmount();
+  });
+
+  test('/panel-demo enseña datos de ejemplo marcados como ficticios, y el panel real no se contamina', async ($, on) => {
+    motor($, on);
+    await $.session.start({ surface: 'terminal', isInteractive: true, cwd: '/prueba' });
+    await $.command.run({ command: 'panel-demo', args: '' } as any);
+    let ui = await $.ui.mount({ ...PANE, surface: 'terminal', props: { ...PANE.props, bodyColumns: 120 } });
+    expect((await ui.find({ type: 'Text', text: /EJEMPLO · datos ficticios/ }))?.text).toBeTruthy();
+    expect((await ui.find({ type: 'Text', text: /DELEGACIÓN/ }))?.text).toBeTruthy();
+    await ui.unmount();
+    await $.command.run({ command: 'panel-demo', args: '' } as any);
+    ui = await $.ui.mount({ ...PANE, surface: 'terminal', props: { ...PANE.props, bodyColumns: 120 } });
+    expect(await ui.find({ type: 'Text', text: /EJEMPLO/ })).toBeFalsy();
+    expect((await ui.find({ type: 'Text', text: /Aún no hay actividad/ }))?.text).toBeTruthy();
+    await ui.unmount();
+  });
+
+  test('guarda una foto del estado real en ~/.nexakit/panel para nexakit panel, sin secretos', async ($, on) => {
+    const escritos: Record<string, string> = {};
+    motor($, on);
+    on('env.get', (_: any, e: any) => ({ value: e.name === 'HOME' ? '/home/prueba' : undefined }));
+    on('session.id', () => ({ value: 'sesion-123' }));
+    on('fs.write', (_: any, e: any) => { escritos[e.path] = e.text; return { value: undefined }; });
+    await $.session.start({ surface: 'terminal', isInteractive: true, cwd: '/prueba' });
+    await paso($, {});
+    await $.tool.call({ tool: 'Bash', command: 'export API_TOKEN=abc123 && npm test' } as any);
+    const foto = JSON.parse(escritos['/home/prueba/.nexakit/panel/actual.json']);
+    expect(foto).toMatchObject({ version: 1, sesion: 'sesion-123', carpeta: 'mi-app' });
+    expect(foto.estado.lider.modelo).toBe('claude-sonnet-5-5');
+    expect(foto.uso.context.percent).toBe(31);
+    expect(JSON.stringify(foto)).not.toContain('abc123');
+    expect(escritos['/home/prueba/.nexakit/panel/sesion-123.json']).toBe(escritos['/home/prueba/.nexakit/panel/actual.json']);
+  });
+
+  test('una revisión que Claude manda a Codex aparece con su modelo y los tokens que informa', async ($, on) => {
+    motor($, on, undefined, false, 'informe\nModelo pedido: gpt-6.1-sol · high · Modelo que respondió: gpt-6.1-sol · high (registro)\nTokens: entrada 41000 (caché 3000) · salida 900\n');
+    await $.session.start({ surface: 'terminal', isInteractive: true, cwd: '/prueba' });
+    await paso($, {});
+    await $.tool.call({ tool: 'Bash', command: '~/.nexakit/nexakit revision --con codex --modelo gpt-6.1-sol --esfuerzo high --encargo /tmp/e.md' } as any);
+    const ui = await $.ui.mount({ ...PANE, surface: 'terminal', props: { ...PANE.props, bodyColumns: 120 } });
+    for (const t of [/REVISIÓN/, /Codex/, /✓ lista/, /tokens 42k/, /codex · revisa/, /\[revisó\]/]) {
+      expect((await ui.find({ type: 'Text', text: t }))?.text, String(t)).toBeTruthy();
+    }
+    await ui.unmount();
+  });
+
+  test('sin actividad el panel lo dice y no inventa nada', async ($, on) => {
+    motor($, on, { startedAt: 0, context: { window: 1000000 }, rateLimits: [] });
+    await $.session.start({ surface: 'terminal', isInteractive: true, cwd: '/prueba' });
+    const ui = await $.ui.mount({ ...PANE, surface: 'terminal' });
+    expect((await ui.find({ type: 'Text', text: /Aún no hay actividad/ }))?.text).toBeTruthy();
+    expect(await ui.find({ type: 'Text', text: /Asesor/ })).toBeFalsy();
+    expect(await ui.find({ type: 'Text', text: /contexto/ })).toBeFalsy();
+    await ui.unmount();
+  });
+
+  test('si falla la lectura del uso, el panel se dibuja igual', async ($, on) => {
+    motor($, on, undefined, true);
+    await $.session.start({ surface: 'terminal', isInteractive: true, cwd: '/prueba' });
+    await paso($, {});
+    const ui = await $.ui.mount({ ...PANE, surface: 'terminal' });
+    expect((await ui.find({ type: 'Text', text: /Sonnet 5\.5/ }))?.text).toBeTruthy();
+    await ui.unmount();
+  });
+});

package/plugins/nexakit-panel/types/index.d.ts

@@ -0,0 +1,41 @@
+export type PanelAgente = {
+  id: string;
+  nombre: string;
+  modelo: string;
+  estado: 'corriendo' | 'listo' | 'error';
+  inicio: number;
+  fin: number | null;
+  herramientas: number;
+  leidos: number;
+  escritos: number;
+  ultimo: string;
+};
+export type PanelRevision = {
+  id: string;
+  ia: string;
+  modelo: string | null;
+  esfuerzo: string | null;
+  estado: 'revisando' | 'lista' | 'error';
+  inicio: number;
+  fin: number | null;
+  entrada: number | null;
+  cache: number | null;
+  salida: number | null;
+  respondio: string | null;
+};
+export type PanelRegistro = { t: number; quien: string; texto: string; ms?: number };
+export type PanelEstado = {
+  lider: { modelo: string | null; esfuerzo: string | null; leidos: number; escritos: number; herramientas: number };
+  agentes: PanelAgente[];
+  asesor: { llamadas: number; ultimo: number | null; tiempo: number };
+  registro: PanelRegistro[];
+  pasos: number;
+  recomendacion: { modelo: string; esfuerzo: string; motivo: string } | null;
+  revisiones: PanelRevision[];
+};
+
+declare module 'claude-code' {
+  interface PluginState {
+    'nexakit-panel': { panel: Shaped<PanelEstado>; demo: Shaped<boolean> };
+  }
+}

package/plugins/nexakit-sesion/.claude-plugin/plugin.json

@@ -0,0 +1 @@
+{"name": "nexakit-sesion", "version": "0.1.0", "description": "Muestra cuánto contexto y cuota llevas y avisa cuándo conviene cerrar la sesión y abrir otra, sin cerrarla por ti.", "license": "MIT"}

package/plugins/nexakit-sesion/README.md

@@ -0,0 +1,12 @@
+# nexakit-sesion
+
+Muestra en la línea de estado de Claude Code cuánto contexto llevas y tus límites de uso de 5 horas y semanal,
+por ejemplo `contexto 42 % · 5 h 14 % · semana 79 %`. Al pasar del 60 % y del 80 % de contexto avisa una vez de
+que es buen momento para escribir el traspaso y abrir una sesión nueva. Solo avisa: nunca cierra la sesión.
+
+Los datos salen de Claude Code (`$.session.usage()`); los límites se mueven en puntos enteros y solo cuando una
+respuesta de la API informa un valor nuevo.
+
+## Pruebas
+
+`claude plugin test plugins/nexakit-sesion`

package/plugins/nexakit-sesion/hooks/aviso.js

@@ -0,0 +1,38 @@
+// Umbrales de contexto a partir de los cuales conviene pensar en una sesión nueva.
+export const UMBRAL_AVISO = 60;
+export const UMBRAL_URGENTE = 80;
+
+const entero = (valor) => Math.round(valor);
+const esNumero = (valor) => typeof valor === 'number' && Number.isFinite(valor);
+
+// 0 = sin aviso, 1 = conviene, 2 = urgente. Sin dato nunca avisa.
+export function avisoDeContexto(percent) {
+  if (!esNumero(percent)) return 0;
+  if (percent >= UMBRAL_URGENTE) return 2;
+  if (percent >= UMBRAL_AVISO) return 1;
+  return 0;
+}
+
+// Línea de estado: solo lo que se conoce; undefined si no hay nada que mostrar.
+export function textoDeEstado(usage) {
+  const partes = [];
+  if (esNumero(usage?.context?.percent)) partes.push(`contexto ${entero(usage.context.percent)} %`);
+  for (const limite of usage?.rateLimits ?? []) {
+    if (!esNumero(limite?.percentUsed)) continue;
+    if (limite.kind === 'five_hour') partes.push(`5 h ${entero(limite.percentUsed)} %`);
+    if (limite.kind === 'seven_day') partes.push(`semana ${entero(limite.percentUsed)} %`);
+  }
+  return partes.length > 0 ? partes.join(' · ') : undefined;
+}
+
+// El aviso solo recomienda: nunca promete ni hace el cierre por la persona.
+export function mensajeDeAviso(nivel, percent) {
+  const p = entero(percent);
+  if (nivel === 1) {
+    return `Contexto al ${p} %. Si vas a cambiar de tarea, es buen momento: escribe el traspaso y abre una sesión nueva.`;
+  }
+  if (nivel === 2) {
+    return `Contexto al ${p} %. Cada turno relee más contexto: cierra esta tarea, escribe el traspaso y abre una sesión nueva.`;
+  }
+  return undefined;
+}

package/plugins/nexakit-sesion/hooks/hooks.json

@@ -0,0 +1 @@
+{"modules":["./register.js"]}

package/plugins/nexakit-sesion/hooks/register.js

@@ -0,0 +1,28 @@
+import { avisoDeContexto, mensajeDeAviso, textoDeEstado } from './aviso.js';
+
+export function register(on) {
+  // Último nivel avisado: solo se vuelve a avisar al subir de nivel o tras bajar y volver a subir.
+  let ultimoAviso = 0;
+
+  on('turn.complete', async ($, e, next) => {
+    try {
+      if (!e.agentId) {
+        const usage = await $.session.usage();
+        $.ui.status(textoDeEstado(usage));
+        const percent = usage?.context?.percent;
+        const nivel = avisoDeContexto(percent);
+        if (nivel > ultimoAviso) $.ui.toast(mensajeDeAviso(nivel, percent), { timeoutMs: 10000 });
+        ultimoAviso = nivel;
+      }
+    } catch {
+      // Medir nunca debe romper el turno.
+    }
+    return next(e);
+  });
+
+  on('session.end', async ($, e, next) => {
+    ultimoAviso = 0;
+    $.ui.status(undefined);
+    return next(e);
+  });
+}

package/plugins/nexakit-sesion/tests/register.test.ts

@@ -0,0 +1,96 @@
+import { describe, expect, test } from 'claude-code/testing';
+import { avisoDeContexto, textoDeEstado, mensajeDeAviso } from '../hooks/aviso.js';
+
+describe('nexakit-sesion · lógica', () => {
+  test('los umbrales avisan al 60 % y al 80 %, y nunca sin dato', () => {
+    expect(avisoDeContexto(0)).toBe(0);
+    expect(avisoDeContexto(59.9)).toBe(0);
+    expect(avisoDeContexto(60)).toBe(1);
+    expect(avisoDeContexto(79.9)).toBe(1);
+    expect(avisoDeContexto(80)).toBe(2);
+    expect(avisoDeContexto(100)).toBe(2);
+    expect(avisoDeContexto(undefined)).toBe(0);
+    expect(avisoDeContexto(Number.NaN)).toBe(0);
+  });
+
+  test('la línea de estado junta contexto y límites de Claude, y omite lo que no se conoce', () => {
+    const usage = {
+      context: { window: 1000000, percent: 41.6 },
+      rateLimits: [
+        { kind: 'five_hour', percentUsed: 88 },
+        { kind: 'seven_day', percentUsed: 14.5 },
+        { kind: 'spend_limit', percentUsed: 3 },
+      ],
+    };
+    expect(textoDeEstado(usage)).toBe('contexto 42 % · 5 h 88 % · semana 15 %');
+    expect(textoDeEstado({ context: { window: 1000 }, rateLimits: [] })).toBeUndefined();
+    expect(textoDeEstado({ context: { window: 1000, percent: 5 }, rateLimits: [] })).toBe('contexto 5 %');
+  });
+
+  test('cada aviso dice el porcentaje, propone el traspaso y no promete cerrar nada', () => {
+    const uno = mensajeDeAviso(1, 62.2);
+    const dos = mensajeDeAviso(2, 83.7);
+    expect(uno).toContain('62 %');
+    expect(dos).toContain('84 %');
+    for (const texto of [uno, dos]) {
+      expect(texto).toContain('traspaso');
+      expect(texto).toContain('sesión nueva');
+    }
+    expect(mensajeDeAviso(0, 10)).toBeUndefined();
+  });
+});
+
+describe('nexakit-sesion · en la sesión', () => {
+  const montar = async ($: any, on: any, porcentajes: number[]) => {
+    const estados: (string | undefined)[] = [];
+    const avisos: string[] = [];
+    let turno = 0;
+    on('session.start', (_: any, e: any) => ({ cwd: e.cwd }));
+    on('turn.complete', () => ({ text: 'listo' }));
+    on('session.end', () => ({ sessionId: 's1' }));
+    on('clock.now', () => ({ value: 0 }));
+    on('fs.write', () => ({ value: undefined }));
+    on('session.usage', () => ({
+      value: { startedAt: 0, context: { window: 1000000, percent: porcentajes[Math.min(turno, porcentajes.length - 1)] }, rateLimits: [] },
+    }));
+    on('ui.status', (_: any, e: any) => {
+      estados.push(e.text);
+      return { value: undefined };
+    });
+    on('ui.toast', (_: any, e: any) => {
+      avisos.push(e.text);
+      return { value: undefined };
+    });
+    await $.session.start({ surface: 'terminal', isInteractive: true, cwd: '/prueba' });
+    const terminar = async () => {
+      await $.turn.complete({ reason: 'answer', answer: 'ok', durationMs: 5, isAborted: false, turnId: `t${turno}` });
+      turno += 1;
+    };
+    return { estados, avisos, terminar };
+  };
+
+  test('avisa una sola vez por umbral y vuelve a avisar si el contexto baja y vuelve a subir', async ($, on) => {
+    const { estados, avisos, terminar } = await montar($, on, [30, 61, 65, 82, 85, 20, 70]);
+    await terminar(); // 30
+    expect(avisos).toHaveLength(0);
+    await terminar(); // 61 -> primer aviso
+    expect(avisos).toHaveLength(1);
+    await terminar(); // 65 -> sin repetir
+    expect(avisos).toHaveLength(1);
+    await terminar(); // 82 -> aviso urgente
+    expect(avisos).toHaveLength(2);
+    expect(avisos[1]).toContain('82 %');
+    await terminar(); // 85 -> sin repetir
+    expect(avisos).toHaveLength(2);
+    await terminar(); // 20 -> tras compactar o limpiar
+    await terminar(); // 70 -> vuelve a avisar
+    expect(avisos).toHaveLength(3);
+    expect(estados.at(-1)).toBe('contexto 70 %');
+  });
+
+  test('al terminar la sesión limpia su línea de estado', async ($, on) => {
+    const { estados } = await montar($, on, [10]);
+    await $.session.end({ reason: 'exit' });
+    expect(estados.at(-1)).toBeUndefined();
+  });
+});

package/plugins/niveles/.claude-plugin/plugin.json

@@ -0,0 +1,5 @@
+{
+  "name": "niveles",
+  "version": "0.1.0",
+  "description": "Agentes por nivel (ligero, normal, exigente, alto) con modelo y esfuerzo fijos para delegar sin cambiar /model."
+}

package/plugins/niveles/agents/nivel-alto.md

@@ -0,0 +1,13 @@
+---
+name: nivel-alto
+description: Ejecuta una tarea delegada de nivel Alto (opus, high). Úsalo solo cuando la skill revision-cruzada indique este nivel para la tarea.
+model: opus
+effort: high
+---
+
+Ejecutas una tarea que te delega la sesión principal de la revisión cruzada, con el nivel Alto (opus, high).
+
+- Haz solo lo que pide la delegación y respeta las reglas del proyecto (CLAUDE.md, AGENTS.md y sus skills).
+- Si la tarea es de código: cambio mínimo, pruebas que lo cubran, y ejecútalas junto con el lint o la compilación que correspondan.
+- No hagas commit, push ni PR, y no envíes, apruebes ni reclames encargos de revisión.
+- Termina con los cambios por archivo, las comprobaciones ejecutadas con su resultado real y lo que no comprobaste.

package/plugins/niveles/agents/nivel-exigente.md

@@ -0,0 +1,13 @@
+---
+name: nivel-exigente
+description: Ejecuta una tarea delegada de nivel Exigente (sonnet, high). Úsalo solo cuando la skill revision-cruzada indique este nivel para la tarea.
+model: sonnet
+effort: high
+---
+
+Ejecutas una tarea que te delega la sesión principal de la revisión cruzada, con el nivel Exigente (sonnet, high).
+
+- Haz solo lo que pide la delegación y respeta las reglas del proyecto (CLAUDE.md, AGENTS.md y sus skills).
+- Si la tarea es de código: cambio mínimo, pruebas que lo cubran, y ejecútalas junto con el lint o la compilación que correspondan.
+- No hagas commit, push ni PR, y no envíes, apruebes ni reclames encargos de revisión.
+- Termina con los cambios por archivo, las comprobaciones ejecutadas con su resultado real y lo que no comprobaste.

package/plugins/niveles/agents/nivel-ligero.md

@@ -0,0 +1,13 @@
+---
+name: nivel-ligero
+description: Ejecuta una tarea delegada de nivel Ligero (haiku, low). Úsalo solo cuando la skill revision-cruzada indique este nivel para la tarea.
+model: haiku
+effort: low
+---
+
+Ejecutas una tarea que te delega la sesión principal de la revisión cruzada, con el nivel Ligero (haiku, low).
+
+- Haz solo lo que pide la delegación y respeta las reglas del proyecto (CLAUDE.md, AGENTS.md y sus skills).
+- Si la tarea es de código: cambio mínimo, pruebas que lo cubran, y ejecútalas junto con el lint o la compilación que correspondan.
+- No hagas commit, push ni PR, y no envíes, apruebes ni reclames encargos de revisión.
+- Termina con los cambios por archivo, las comprobaciones ejecutadas con su resultado real y lo que no comprobaste.

package/plugins/niveles/agents/nivel-normal.md

@@ -0,0 +1,13 @@
+---
+name: nivel-normal
+description: Ejecuta una tarea delegada de nivel Normal (sonnet, medium). Úsalo solo cuando la skill revision-cruzada indique este nivel para la tarea.
+model: sonnet
+effort: medium
+---
+
+Ejecutas una tarea que te delega la sesión principal de la revisión cruzada, con el nivel Normal (sonnet, medium).
+
+- Haz solo lo que pide la delegación y respeta las reglas del proyecto (CLAUDE.md, AGENTS.md y sus skills).
+- Si la tarea es de código: cambio mínimo, pruebas que lo cubran, y ejecútalas junto con el lint o la compilación que correspondan.
+- No hagas commit, push ni PR, y no envíes, apruebes ni reclames encargos de revisión.
+- Termina con los cambios por archivo, las comprobaciones ejecutadas con su resultado real y lo que no comprobaste.