nexakit 0.1.0 → 0.2.0

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

@@ -0,0 +1,240 @@
+import { describe, expect, test } from 'claude-code/testing';
+import {
+  alias, barra, barraEsfuerzo, crear, duracion, ejemplo, estadoPorFamilia, etiquetaEnjambre, etiquetaModelo, familia, hora,
+  iniciarAgente, registrarAsesor, registrarHerramienta, registrarPaso, registrarRecomendacion, registrarUso, resumenDelegacion, sinSecretos, esRevision, iniciarRevision, leerSalidaRevision, terminarRevision, terminarAgente, tituloDeOrquesta, tokens,
+} from '../hooks/panel.js';
+
+describe('nexakit-panel · lógica', () => {
+  test('el nombre del modelo se lee como persona: familia y versión', () => {
+    expect(etiquetaModelo('claude-sonnet-5-5')).toBe('Sonnet 5.5');
+    expect(etiquetaModelo('claude-opus-5-5')).toBe('Opus 5.5');
+    expect(etiquetaModelo('claude-haiku-5-5')).toBe('Haiku 5.5');
+    expect(etiquetaModelo('claude-sonnet-4-20250514')).toBe('Sonnet 4');
+    expect(etiquetaModelo('claude-sonnet-4-5-20250929')).toBe('Sonnet 4.5');
+    expect(etiquetaModelo('sonnet')).toBe('Sonnet');
+    expect(etiquetaModelo('modelo-raro')).toBe('modelo-raro');
+    expect(etiquetaModelo(null)).toBe('modelo ?');
+  });
+
+  test('la familia decide el color del modelo', () => {
+    expect(familia('claude-haiku-5-5')).toBe('haiku');
+    expect(familia('claude-sonnet-5-5')).toBe('sonnet');
+    expect(familia('claude-opus-5-5')).toBe('opus');
+    expect(familia('otra-cosa')).toBe('otro');
+    expect(familia(undefined)).toBe('otro');
+  });
+
+  test('el esfuerzo se dibuja como barra de 4', () => {
+    expect(barraEsfuerzo('low')).toBe('▮▯▯▯');
+    expect(barraEsfuerzo('medium')).toBe('▮▮▯▯');
+    expect(barraEsfuerzo('high')).toBe('▮▮▮▯');
+    expect(barraEsfuerzo('xhigh')).toBe('▮▮▮▮');
+    expect(barraEsfuerzo('max')).toBe('▮▮▮▮');
+    expect(barraEsfuerzo(null)).toBe('▯▯▯▯');
+  });
+
+  test('duración y hora legibles', () => {
+    expect(duracion(400)).toBe('0 s');
+    expect(duracion(12_400)).toBe('12 s');
+    expect(duracion(75_000)).toBe('1 min 15 s');
+    expect(hora(new Date(2026, 10, 4, 9, 5, 7).getTime())).toBe('09:05:07');
+  });
+
+  test('un paso de la sesión principal fija el líder; el de un subagente solo su modelo', () => {
+    let s = crear();
+    s = registrarPaso(s, { modelo: 'claude-sonnet-5-5', esfuerzo: 'high', at: 1 });
+    expect(s.lider).toMatchObject({ modelo: 'claude-sonnet-5-5', esfuerzo: 'high', leidos: 0, escritos: 0 });
+    expect(s.pasos).toBe(1);
+    s = iniciarAgente(s, { id: 'a1', nombre: 'search', modelo: 'claude-haiku-5-5', at: 2 });
+    s = registrarPaso(s, { modelo: 'claude-haiku-5-5', esfuerzo: 'low', agentId: 'a1', at: 3 });
+    expect(s.lider.modelo).toBe('claude-sonnet-5-5');
+    expect(s.pasos).toBe(1);
+  });
+
+  test('un subagente empieza, cuenta herramientas y termina, y todo queda en el registro', () => {
+    let s = crear();
+    s = iniciarAgente(s, { id: 'a1', nombre: 'grep', modelo: 'claude-haiku-5-5', at: 1000 });
+    expect(s.agentes[0]).toMatchObject({ id: 'a1', estado: 'corriendo', herramientas: 0, fin: null });
+    s = registrarHerramienta(s, { tool: 'Grep', detalle: 'auth', agentId: 'a1', at: 2000 });
+    s = registrarHerramienta(s, { tool: 'Read', detalle: 'src/auth.ts', at: 3000 });
+    expect(s.agentes[0].herramientas).toBe(1);
+    s = terminarAgente(s, { id: 'a1', ok: true, at: 5000 });
+    expect(s.agentes[0]).toMatchObject({ estado: 'listo', fin: 5000 });
+    expect(s.registro.map((r) => r.quien)).toEqual(['grep', 'grep', 'líder', 'grep']);
+    s = terminarAgente(iniciarAgente(s, { id: 'a2', nombre: 'audit', modelo: 'x', at: 6000 }), { id: 'a2', ok: false, at: 7000 });
+    expect(s.agentes[1].estado).toBe('error');
+  });
+
+  test('las consultas al asesor se acumulan y cero consultas no ensucian nada', () => {
+    let s = crear();
+    expect(registrarAsesor(s, { llamadas: 0, at: 1 })).toBe(s);
+    s = registrarAsesor(s, { llamadas: 1, at: 10 });
+    s = registrarAsesor(s, { llamadas: 2, at: 20 });
+    expect(s.asesor).toMatchObject({ llamadas: 3, ultimo: 20 });
+    expect(s.registro.at(-1)?.texto).toContain('2 veces');
+    expect(s.registro.at(0)?.texto).toContain('1 vez');
+  });
+
+  test('el registro y la lista de agentes tienen tope y no crecen sin límite', () => {
+    let s = crear();
+    for (let i = 0; i < 200; i++) s = registrarHerramienta(s, { tool: 'Read', detalle: `f${i}`, at: i });
+    expect(s.registro.length).toBe(60);
+    expect(s.registro.at(-1)?.texto).toContain('f199');
+    for (let i = 0; i < 20; i++) s = iniciarAgente(s, { id: `a${i}`, nombre: `n${i}`, modelo: 'm', at: i });
+    expect(s.agentes.length).toBe(8);
+    expect(s.agentes.at(-1)?.id).toBe('a19');
+  });
+
+  test('un evento de un agente desconocido no rompe nada', () => {
+    const s = crear();
+    expect(terminarAgente(s, { id: 'no-existe', ok: true, at: 1 }).agentes).toEqual([]);
+    expect(registrarHerramienta(s, { tool: 'Bash', detalle: 'ls', agentId: 'no-existe', at: 1 }).registro[0].quien).toBe('agente');
+  });
+});
+
+describe('nexakit-panel · diagrama', () => {
+  const con = (agentes: Array<[string, string, 'corriendo' | 'listo' | 'error', number]>) => {
+    let s = crear();
+    s = registrarPaso(s, { modelo: 'claude-sonnet-5-5', esfuerzo: 'high' });
+    agentes.forEach(([nombre, modelo, estado, tools], i) => {
+      s = iniciarAgente(s, { id: 'a' + i, nombre, modelo, at: i });
+      for (let k = 0; k < tools; k++) s = registrarHerramienta(s, { tool: 'Read', detalle: 'f', agentId: 'a' + i, at: 10 + k });
+      if (estado !== 'corriendo') s = terminarAgente(s, { id: 'a' + i, ok: estado === 'listo', at: 99 });
+    });
+    return s;
+  };
+
+  test('la barra es proporcional, de ancho fijo y nunca se pasa', () => {
+    expect(barra(0, 10)).toBe('░░░░░░░░░░');
+    expect(barra(0.5, 10)).toBe('█████░░░░░');
+    expect(barra(1, 10)).toBe('██████████');
+    expect(barra(2, 4)).toBe('████');
+    expect(barra(-1, 4)).toBe('░░░░');
+    expect(barra(Number.NaN, 4)).toBe('░░░░');
+  });
+
+  test('el resumen de delegación cuenta lo real', () => {
+    const s = con([['search', 'claude-haiku-5-5', 'listo', 2], ['grep', 'claude-haiku-5-5', 'corriendo', 1], ['audit', 'claude-haiku-5-5', 'error', 0], ['otro', 'claude-haiku-5-5', 'listo', 4]]);
+    expect(resumenDelegacion(s.agentes)).toEqual({ total: 4, corriendo: 1, listos: 2, errores: 1, herramientas: 7 });
+    expect(resumenDelegacion([])).toEqual({ total: 0, corriendo: 0, listos: 0, errores: 0, herramientas: 0 });
+  });
+
+  test('el título nombra al líder y, si hay subagentes, a su familia más usada', () => {
+    expect(tituloDeOrquesta(crear())).toBe('NEXAKIT · ORQUESTA');
+    const solo = registrarPaso(crear(), { modelo: 'claude-sonnet-5-5', esfuerzo: 'high' });
+    expect(tituloDeOrquesta(solo)).toBe('NEXAKIT · ORQUESTA · SONNET 5.5 DIRIGE');
+    const mixto = con([['a', 'claude-haiku-5-5', 'corriendo', 0], ['b', 'claude-haiku-5-5', 'listo', 0], ['c', 'claude-opus-5-5', 'listo', 0]]);
+    expect(tituloDeOrquesta(mixto)).toBe('NEXAKIT · ORQUESTA · SONNET 5.5 DIRIGE · HAIKU 5.5 EN ENJAMBRE');
+  });
+
+  test('la línea de estado dice por familia qué ocurre y no inventa lo que no ocurre', () => {
+    const s = registrarAsesor(con([['a', 'claude-haiku-5-5', 'corriendo', 0], ['b', 'claude-haiku-5-5', 'listo', 0]]), { llamadas: 2, at: 5 });
+    expect(estadoPorFamilia(s)).toEqual(['haiku [enjambre]', 'subagentes [1/2]', 'asesor [consultado 2]']);
+    expect(estadoPorFamilia(crear())).toEqual([]);
+    expect(estadoPorFamilia(con([['a', 'claude-haiku-5-5', 'listo', 0]]))).toEqual(['haiku [listo]', 'subagentes [1/1]']);
+  });
+
+  test('el alias es lo que se escribe en --model', () => {
+    expect(alias('claude-sonnet-5-5')).toBe('sonnet');
+    expect(alias('claude-opus-5-5')).toBe('opus');
+    expect(alias('rara')).toBe('rara');
+    expect(alias(null)).toBe('?');
+  });
+
+  test('la etiqueta del enjambre es la misma que usa el título', () => {
+    expect(etiquetaEnjambre([])).toBeNull();
+    const mixto = con([['a', 'claude-haiku-5-5', 'corriendo', 0], ['b', 'claude-haiku-5-5', 'listo', 0], ['c', 'claude-opus-5-5', 'listo', 0]]);
+    expect(etiquetaEnjambre(mixto.agentes)).toBe('Haiku 5.5');
+    expect(tituloDeOrquesta(mixto)).toContain(etiquetaEnjambre(mixto.agentes)!.toUpperCase());
+  });
+
+  test('el ejemplo es determinista y trae de todo para juzgar el diseño: líder, asesor, tres subagentes y registro', () => {
+    const e = ejemplo(1_000_000);
+    expect(e).toEqual(ejemplo(1_000_000));
+    expect(e.lider.modelo).toBe('claude-sonnet-5-5');
+    expect(e.asesor.llamadas).toBeGreaterThan(0);
+    expect(e.agentes.map((a) => a.estado).sort()).toEqual(['corriendo', 'corriendo', 'listo']);
+    expect(e.registro.length).toBeGreaterThan(5);
+    expect(Math.max(...e.registro.map((r) => r.t))).toBeLessThanOrEqual(1_000_000);
+  });
+
+  test('el uso real se acumula: leídos = entrada + caché, escritos = salida, por líder y por subagente', () => {
+    const u = (i: number, o: number, cr: number, cw: number) => ({ input_tokens: i, output_tokens: o, cache_read_input_tokens: cr, cache_creation_input_tokens: cw, model: 'm' });
+    let s = iniciarAgente(crear(), { id: 'a1', nombre: 'search', modelo: 'claude-haiku-5-5', at: 1 });
+    s = registrarUso(s, { usage: u(100, 20, 1000, 50) });
+    s = registrarUso(s, { usage: u(10, 5, 0, 0) });
+    s = registrarUso(s, { agentId: 'a1', usage: u(7, 3, 300, 0) });
+    s = registrarUso(s, { agentId: 'desconocido', usage: u(1, 1, 1, 1) });
+    s = registrarUso(s, { usage: null });
+    expect(s.lider).toMatchObject({ leidos: 1160, escritos: 25 });
+    expect(s.agentes[0]).toMatchObject({ leidos: 307, escritos: 3 });
+  });
+
+  test('el asesor acumula su tiempo y cada subagente recuerda su última acción', () => {
+    let s = registrarAsesor(crear(), { llamadas: 1, at: 10, tiempo: 1500 });
+    s = registrarAsesor(s, { llamadas: 1, at: 20, tiempo: 500 });
+    expect(s.asesor).toMatchObject({ llamadas: 2, tiempo: 2000 });
+    s = iniciarAgente(s, { id: 'a1', nombre: 'grep', modelo: 'claude-haiku-5-5', at: 1 });
+    s = registrarHerramienta(s, { tool: 'Grep', detalle: 'verifyToken', agentId: 'a1', at: 2 });
+    expect(s.agentes[0].ultimo).toBe('Grep · verifyToken');
+  });
+
+  test('los tokens se leen en k y M', () => {
+    expect(tokens(0)).toBe('0');
+    expect(tokens(999)).toBe('999');
+    expect(tokens(1500)).toBe('1.5k');
+    expect(tokens(668_400)).toBe('668k');
+    expect(tokens(2_340_000)).toBe('2.3M');
+  });
+
+  test('el líder cuenta sus herramientas aunque el registro tenga tope', () => {
+    let s = crear();
+    for (let i = 0; i < 150; i++) s = registrarHerramienta(s, { tool: 'Read', detalle: 'f', at: i });
+    expect(s.lider.herramientas).toBe(150);
+  });
+
+  test('cada consulta al asesor guarda cuánto duró', () => {
+    const s = registrarAsesor(crear(), { llamadas: 1, at: 10, tiempo: 4200 });
+    expect(s.registro.at(-1)).toMatchObject({ quien: 'asesor', ms: 4200 });
+  });
+
+  test('la recomendación de modelo se guarda tal cual llega', () => {
+    const s = registrarRecomendacion(crear(), { modelo: 'sonnet', esfuerzo: 'medium', motivo: 'uso diario' });
+    expect(s.recomendacion).toEqual({ modelo: 'sonnet', esfuerzo: 'medium', motivo: 'uso diario' });
+    expect(crear().recomendacion).toBeNull();
+  });
+
+  test('los detalles se guardan sin secretos evidentes', () => {
+    expect(sinSecretos('export GITHUB_TOKEN=ghp_abc123 && npm test')).toBe('export GITHUB_TOKEN=*** && npm test');
+    expect(sinSecretos('curl -H "Authorization: Bearer abc.def" x')).toBe('curl -H "Authorization: Bearer ***" x');
+    expect(sinSecretos('API_KEY=sk-123 node app')).toBe('API_KEY=*** node app');
+    expect(sinSecretos('mysql --password=hunter2 db')).toBe('mysql --password=*** db');
+    expect(sinSecretos('npm test')).toBe('npm test');
+  });
+
+  test('reconoce una revisión enviada a otra IA y no confunde la consulta de disponibles', () => {
+    expect(esRevision('~/.nexakit/nexakit revision --con codex --modelo gpt-6.1-sol --esfuerzo high --encargo /tmp/e.md')).toEqual({ ia: 'codex', modelo: 'gpt-6.1-sol', esfuerzo: 'high' });
+    expect(esRevision('C:\\Users\\x\\.nexakit\\nexakit.cmd revision --con antigravity --modelo gemini-3.8-flash-high --esfuerzo high --encargo e.md')).toMatchObject({ ia: 'antigravity' });
+    expect(esRevision('~/.nexakit/nexakit revision --disponibles --principal claude')).toBeNull();
+    expect(esRevision('npm test')).toBeNull();
+  });
+
+  test('lee del resultado de la revisión el modelo que respondió y los tokens reales', () => {
+    const salida = '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';
+    expect(leerSalidaRevision(salida)).toEqual({ respondio: 'gpt-6.1-sol', entrada: 41000, cache: 3000, salida: 900 });
+    expect(leerSalidaRevision('Tokens: entrada no informado (caché no informado) · salida no informado')).toEqual({ respondio: null, entrada: null, cache: null, salida: null });
+    expect(leerSalidaRevision('')).toEqual({ respondio: null, entrada: null, cache: null, salida: null });
+  });
+
+  test('una revisión empieza, termina con sus cifras y se ve en el estado y el registro', () => {
+    let s = iniciarRevision(crear(), { id: 'r1', ia: 'codex', modelo: 'gpt-6.1-sol', esfuerzo: 'high', at: 1000 });
+    expect(s.revisiones[0]).toMatchObject({ ia: 'codex', estado: 'revisando', fin: null });
+    expect(estadoPorFamilia(s)).toContain('codex [revisando]');
+    s = terminarRevision(s, { id: 'r1', ok: true, at: 46_000, cifras: { respondio: 'gpt-6.1-sol', entrada: 41000, cache: 3000, salida: 900 } });
+    expect(s.revisiones[0]).toMatchObject({ estado: 'lista', fin: 46_000, entrada: 41000, salida: 900 });
+    expect(estadoPorFamilia(s)).toContain('codex [revisó]');
+    expect(s.registro.map((r) => r.quien)).toEqual(['codex', 'codex']);
+    expect(terminarRevision(s, { id: 'no', ok: true, at: 1, cifras: null })).toBe(s);
+  });
+});
+

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();
+  });
+});