nexakit 0.0.0-stage → 0.2.0

package/plugins/nexakit-panel/hooks/register.tsx

@@ -0,0 +1,248 @@
+import { atom, read, update } from 'claude-code'
+import type { Register } from 'claude-code'
+
+import type { PanelEstado } from '../types'
+import { ANCHO, dibujar, medidoresDeUso, modeloFrenteARecomendado, tramosParaPanel } from './lienzo.js'
+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, textoDeUso, tituloDeOrquesta,
+} from './panel.js'
+
+const PANE = 'panel'
+const TITULO = 'Orquesta'
+// Desde este ancho cabe el diagrama de varias columnas; por debajo se dibuja una lista vertical.
+const ANCHO_DIAGRAMA = ANCHO
+const RECOMENDACION = 'mcp__nexakit-modelo__nexakit_recomendacion'
+// Cambia la etiqueta cuando cambien los campos del estado: descarta lo que guardó una versión anterior.
+const panel = atom({ plugin: 'nexakit-panel', key: 'panel' } as const, crear() as PanelEstado, { shape: 'panel-4' })
+// Con `/panel-demo` el panel enseña datos de ejemplo (marcados como tales) sin tocar los reales.
+const demo = atom({ plugin: 'nexakit-panel', key: 'demo' } as const, false, { shape: 'demo-1' })
+
+const COLOR = {
+  sonnet: '#fb923c', haiku: '#60a5fa', opus: '#a78bfa', fable: '#f472b6', otro: '#9ca3af', ok: '#4ade80', error: '#f87171', marca: '#a78bfa',
+} as const
+const colorDe = (modelo: string | null) => COLOR[familia(modelo) as keyof typeof COLOR] ?? COLOR.otro
+
+// Un detalle corto de lo que hizo la herramienta, sin volcar contenido.
+const breve = (entrada: Record<string, unknown>) => {
+  const valor = entrada.file_path ?? entrada.command ?? entrada.pattern ?? entrada.path ?? entrada.description ?? entrada.url ?? ''
+  return sinSecretos(String(valor).replace(/\s+/gu, ' ')).slice(0, 48)
+}
+
+// Foto del estado real para `nexakit panel`, que la dibuja a pantalla completa en otra división de la terminal.
+async function guardarFoto($: Parameters<Parameters<Register>[0]>[1] extends never ? never : any) {
+  try {
+    const home = (await $.env.get('HOME')) || (await $.env.get('USERPROFILE'))
+    if (!home) return
+    const sesion = await $.session.id()
+    const estado = await read($, panel)
+    let uso = null
+    try { uso = await $.session.usage() } catch { /* sin uso */ }
+    let carpeta = ''
+    try { carpeta = String(await $.session.cwd()).split(/[\\/]/u).filter(Boolean).pop() ?? '' } catch { /* sin carpeta */ }
+    let asesorModelo: string | null = null
+    try { const valor = await $.settings.get('advisorModel'); asesorModelo = typeof valor === 'string' && valor ? valor : null } catch { /* sin ajuste */ }
+    const foto = JSON.stringify({ version: 1, sesion, actualizado: await $.clock.now(), carpeta, asesorModelo, uso, estado })
+    const carpetaFotos = `${home}/.nexakit/panel`
+    await $.fs.write(`${carpetaFotos}/${sesion}.json`, foto)
+    await $.fs.write(`${carpetaFotos}/actual.json`, foto)
+  } catch { /* la foto es un extra: nunca rompe la sesión */ }
+}
+
+export const register: Register = on => {
+  on('session.start', async ($, e, next) => {
+    await $.command.register({ name: 'panel', description: 'Abre el panel de la orquestación de esta sesión' })
+    await $.command.register({ name: 'panel-demo', description: 'Activa o desactiva datos de ejemplo en el panel, para ver el diseño' })
+    void $.ui.open({ id: PANE, title: TITULO, columns: ANCHO_DIAGRAMA })
+    return next(e)
+  })
+
+  on('command.run', { command: 'panel' }, async $ => {
+    await $.ui.open({ id: PANE, title: TITULO, columns: ANCHO_DIAGRAMA })
+    return { text: 'Panel de la orquestación abierto.' }
+  })
+
+  on('command.run', { command: 'panel-demo' }, async $ => {
+    const activo = !(await read($, demo))
+    await update($, demo, () => activo)
+    await $.ui.open({ id: PANE, title: TITULO, columns: ANCHO_DIAGRAMA })
+    return { text: activo ? 'Panel con datos de ejemplo (ficticios). Repite /panel-demo para volver a los reales.' : 'Panel con los datos reales de la sesión.' }
+  })
+
+  on('turn.step', async function* ($, e, next) {
+    try {
+      await update($, panel, s => registrarPaso(s, { modelo: e.model, esfuerzo: e.effort == null ? null : String(e.effort), agentId: e.agentId }))
+    } catch { /* observar nunca debe romper la sesión */ }
+    const result = yield* next(e)
+    try {
+      const asesor = (result?.serverToolUses ?? []).filter(uso => uso.name === 'advisor')
+      const at = await $.clock.now()
+      const usage = result?.usage ?? null
+      const agentId = e.agentId
+      await update($, panel, s => {
+        let siguiente = registrarUso(s, { agentId, usage })
+        if (asesor.length > 0) {
+          const tiempo = asesor.reduce((n, u) => n + Math.max(0, (u.endedAt ?? u.startedAt) - u.startedAt), 0)
+          siguiente = registrarAsesor(siguiente, { llamadas: asesor.length, at, tiempo })
+        }
+        return siguiente
+      })
+    } catch { /* idem */ }
+    await guardarFoto($)
+    return result
+  })
+
+  on('agent.spawn', async ($, e, next) => {
+    const salida = await next(e)
+    try {
+      if ('agentId' in salida && salida.agentId) {
+        const at = await $.clock.now()
+        const id = salida.agentId
+        const nombre = e.name ?? e.subagentType ?? e.description ?? 'agente'
+        await update($, panel, s => iniciarAgente(s, { id, nombre: String(nombre).slice(0, 24), modelo: salida.model ?? '', at }))
+        await guardarFoto($)
+      }
+    } catch { /* idem */ }
+    return salida
+  })
+
+  on('turn.complete', async ($, e, next) => {
+    try {
+      if (e.agentId) {
+        const at = await $.clock.now()
+        const id = e.agentId
+        await update($, panel, s => terminarAgente(s, { id, ok: e.reason === 'answer', at }))
+      }
+      await guardarFoto($)
+    } catch { /* idem */ }
+    return next(e)
+  })
+
+  on('tool.call', async ($, e, next) => {
+    const entrada = e as unknown as Record<string, unknown>
+    let revision: { id: string } | null = null
+    try {
+      const at = await $.clock.now()
+      const detalle = breve(entrada)
+      const pedida = e.tool === 'Bash' ? esRevision(entrada.command) : null
+      if (pedida) revision = { id: String(entrada.tool_use_id ?? at) }
+      await update($, panel, s => {
+        let siguiente = registrarHerramienta(s, { tool: e.tool, detalle, agentId: e.agentId, at })
+        if (e.tool === RECOMENDACION) {
+          siguiente = registrarRecomendacion(siguiente, { modelo: String(entrada.model ?? ''), esfuerzo: String(entrada.effort ?? ''), motivo: String(entrada.reason ?? '') })
+        }
+        if (pedida && revision) siguiente = iniciarRevision(siguiente, { id: revision.id, ...pedida, at })
+        return siguiente
+      })
+      await guardarFoto($)
+    } catch { /* idem */ }
+    const resultado = await next(e)
+    if (revision) {
+      try {
+        const at = await $.clock.now()
+        const r = resultado as { result?: { stdout?: string }; text?: string; isError?: boolean; deny?: string }
+        const cifras = leerSalidaRevision(r?.result?.stdout ?? r?.text ?? '')
+        const id = revision.id
+        await update($, panel, s => terminarRevision(s, { id, ok: !r?.isError && !r?.deny, at, cifras }))
+        await guardarFoto($)
+      } catch { /* idem */ }
+    }
+    return resultado
+  })
+
+  on('session.end', async ($, e, next) => {
+    try { await update($, panel, () => crear() as PanelEstado) } catch { /* idem */ }
+    return next(e)
+  })
+
+  on('ui.render', { component: 'Pane', requestId: PANE }, async ($, e) => {
+    const { Box, Text } = $.ui.resolve(e)
+    const ahora = await $.clock.now()
+    const esEjemplo = await read($, demo)
+    const s = esEjemplo ? ejemplo(ahora) : await read($, panel)
+    let uso = null
+    try { uso = await $.session.usage() } catch { /* sin datos de uso: el panel sigue */ }
+    let carpeta = ''
+    try { carpeta = String(await $.session.cwd()).split('/').filter(Boolean).pop() ?? '' } catch { /* sin directorio */ }
+    const linea = textoDeUso(uso)
+    const ancho = (e.props as { bodyColumns?: number } | undefined)?.bodyColumns ?? e.viewport?.columns ?? 80
+    const filas = Math.max(6, (e.viewport?.rows ?? 30) - 4)
+    const vacio = !esEjemplo && s.pasos === 0 && s.agentes.length === 0 && s.registro.length === 0
+    const quienColor = (quien: string) => {
+      if (quien === 'líder') return colorDe(s.lider.modelo)
+      if (quien === 'asesor') return COLOR.opus
+      const agente = s.agentes.find(a => a.nombre === quien)
+      return agente ? colorDe(agente.modelo) : COLOR.otro
+    }
+
+    let asesorModelo: string | null = null
+    try { const valor = await $.settings.get('advisorModel'); asesorModelo = typeof valor === 'string' && valor ? valor : null } catch { /* sin ajuste */ }
+
+    // ---- Diagrama exacto, carácter a carácter, cuando cabe -------------------------------------------------
+    if (ancho >= ANCHO) {
+      const { filas: lineas } = dibujar(s, { ahora, uso, carpeta, filasMax: e.viewport?.rows, asesorModelo, esEjemplo })
+      return (
+        <Box flexDirection="column">
+          {tramosParaPanel(lineas).map(tramos => (
+            <Box flexDirection="row">
+              {tramos.map(t => (
+                <Text mono wrap="truncate" color={t.c} bold={t.b} dimColor={t.d} backgroundColor={t.bg}>{t.t}</Text>
+              ))}
+            </Box>
+          ))}
+        </Box>
+      )
+    }
+
+    // ---- Versión estrecha: lista vertical, con aviso de cómo ver el diagrama ------------------------------
+    {
+      return (
+        <Box flexDirection="column" gap={1}>
+          <Text bold color={COLOR.marca}>NEXAKIT · ORQUESTA</Text>
+          {esEjemplo && <Text color="#facc15">EJEMPLO · datos ficticios para ver el diseño</Text>}
+          <Text dimColor>{`El diagrama completo necesita ${ANCHO} columnas (ahora ${ancho}). Amplía la ventana o el panel.`}</Text>
+          {vacio && <Text dimColor>Aún no hay actividad en esta sesión.</Text>}
+
+          {s.lider.modelo && (
+            <Box flexDirection="column" borderStyle="round" borderColor={colorDe(s.lider.modelo)} paddingX={1}>
+              <Text bold color={colorDe(s.lider.modelo)}>{`${etiquetaModelo(s.lider.modelo)} · sesión principal`}</Text>
+              <Text>{`esfuerzo ${barraEsfuerzo(s.lider.esfuerzo)} ${s.lider.esfuerzo ?? ''}`.trimEnd()}</Text>
+            </Box>
+          )}
+
+          {s.asesor.llamadas > 0 && (
+            <Box flexDirection="column" borderStyle="round" borderColor={COLOR.opus} paddingX={1}>
+              <Text bold color={COLOR.opus}>{`Asesor · consultas ${s.asesor.llamadas}`}</Text>
+              {s.asesor.ultimo != null && <Text dimColor>{`última a las ${hora(s.asesor.ultimo)}`}</Text>}
+            </Box>
+          )}
+
+          {s.agentes.length > 0 && <Text bold>Subagentes</Text>}
+          {s.agentes.map(agente => (
+            <Box key={agente.id} flexDirection="column" borderStyle="round" borderColor={colorDe(agente.modelo)} paddingX={1}>
+              <Text bold color={colorDe(agente.modelo)}>{agente.nombre}</Text>
+              <Text dimColor>{etiquetaModelo(agente.modelo)}</Text>
+              <Text color={agente.estado === 'listo' ? COLOR.ok : agente.estado === 'error' ? COLOR.error : undefined}>
+                {agente.estado === 'listo' ? '✓ listo' : agente.estado === 'error' ? '✗ con error' : '● corriendo'}
+              </Text>
+              <Text dimColor>{`${agente.herramientas} herramientas · ${duracion((agente.fin ?? ahora) - agente.inicio)}`}</Text>
+            </Box>
+          ))}
+
+          {s.registro.length > 0 && (
+            <Box flexDirection="column" borderStyle="single" borderColor={COLOR.otro} paddingX={1}>
+              <Text bold dimColor>registro</Text>
+              {s.registro.slice(-filas).map(r => (
+                <Text>{`${hora(r.t)}  ${r.quien}  ${r.texto}`}</Text>
+              ))}
+            </Box>
+          )}
+
+          {medidoresDeUso(uso).length > 0 && <Text dimColor>{medidoresDeUso(uso).map(([n, p]) => `${n} ${barra(p / 100, 8)} ${Math.round(p)} %`).join('   ')}</Text>}
+          {s.lider.modelo && (() => { const m = modeloFrenteARecomendado(s); return <Text color={m.coincide ? COLOR.ok : '#facc15'}>{`${m.actual}${m.cola}`}</Text> })()}
+        </Box>
+      )
+    }
+  })
+}

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

@@ -0,0 +1,142 @@
+import { describe, expect, test } from 'claude-code/testing';
+import { ANCHO, aAnsi, dibujar, texto } from '../hooks/lienzo.js';
+import { crear, ejemplo, iniciarRevision, registrarPaso, registrarRecomendacion } from '../hooks/panel.js';
+
+const AHORA = 1_800_000_000_000;
+const USO = { context: { window: 1000000, percent: 31 }, rateLimits: [{ kind: 'five_hour', percentUsed: 43 }, { kind: 'seven_day', percentUsed: 60 }] };
+const demo = () => texto(dibujar(ejemplo(AHORA), { ahora: AHORA, uso: USO, carpeta: 'mi-app' }).filas);
+const cuenta = (lineas: string[], c: string) => lineas.join('').split(c).length - 1;
+
+describe('nexakit-panel · lienzo', () => {
+  test('cada línea mide exactamente el ancho del diagrama', () => {
+    const lineas = demo();
+    expect(ANCHO).toBe(104);
+    for (const l of lineas) expect([...l].length).toBe(ANCHO);
+  });
+
+  test('cabecera: título centrado, regla doble y leyenda', () => {
+    const l = demo();
+    expect(l[0]).toContain('NEXAKIT · ORQUESTA · SONNET 5.5 DIRIGE · HAIKU 5.5 EN ENJAMBRE');
+    expect(l[1]).toMatch(/═{90,}/);
+    expect(l[2]).toContain('■ sonnet 5.5 · líder');
+    expect(l[2]).toContain('■ haiku 5.5 · enjambre');
+    expect(l[2]).toContain('■ delegación');
+    expect(l[2]).toContain('■ asesor');
+  });
+
+  test('todas las cajas y conectores quedan cerrados', () => {
+    const l = demo();
+    expect(cuenta(l, '┌')).toBe(cuenta(l, '┐'));
+    expect(cuenta(l, '└')).toBe(cuenta(l, '┘'));
+  });
+
+  test('líder, delegación, subagentes en fila y vuelta al líder, con uso real', () => {
+    const l = demo().join('\n');
+    expect(l).toContain('Sonnet 5.5 · sesión principal');
+    expect(l).toMatch(/esfuerzo ▮▮▮▯ high/);
+    expect(l).toMatch(/leídos \S+ · escritos \S+/);
+    expect(l).toMatch(/DELEGACIÓN · subagentes +3/);
+    expect(l).toMatch(/listos +█*░* +1\/3/);
+    expect(l).toMatch(/corriendo +█*░* +2\/3/);
+    expect(l).toContain('delegar a subagentes · Haiku 5.5');
+    expect(l).toContain('de vuelta en Sonnet 5.5 · líder');
+    const fila = demo().find((x) => x.includes('search') && x.includes('grep') && x.includes('audit'));
+    expect(fila).toBeTruthy();
+  });
+
+  test('el porcentaje de cada subagente es su parte real del uso y suma 100', () => {
+    const fila = demo().find((x) => (x.match(/\d+%/g) ?? []).length === 3)!;
+    expect(fila).toBeTruthy();
+    const suma = (fila.match(/(\d+)%/g) ?? []).map((p) => Number(p.slice(0, -1))).reduce((a, b) => a + b, 0);
+    expect(Math.abs(suma - 100)).toBeLessThanOrEqual(2);
+  });
+
+  test('asesor a la izquierda con sus consultas, flechas y cifras', () => {
+    const l = demo();
+    expect(l.some((x) => x.includes('ASESOR'))).toBe(true);
+    expect(l.some((x) => /◆ \d\d:\d\d:\d\d/.test(x))).toBe(true);
+    expect(l.some((x) => x.includes('┈▶'))).toBe(true);
+    expect(l.some((x) => /consultas +2/.test(x))).toBe(true);
+  });
+
+  test('registro con título en el borde, y abajo la orden y el estado', () => {
+    const l = demo();
+    expect(l.some((x) => x.includes('┤ registro de sesión ├'))).toBe(true);
+    expect(l.some((x) => x.includes('→ src/auth.ts'))).toBe(true);
+    expect(l.some((x) => x.includes('mi-app $ claude --model sonnet'))).toBe(true);
+    expect(l.some((x) => /haiku \[enjambre\] +subagentes \[1\/3\] +asesor \[consultado 2\]/.test(x))).toBe(true);
+    expect(l.some((x) => /contexto +█+░* +31 %/.test(x))).toBe(true);
+  });
+
+  test('sin actividad no dibuja cajas inventadas', () => {
+    const l = texto(dibujar(crear(), { ahora: AHORA, uso: null, carpeta: 'mi-app' }).filas);
+    expect(l.join('\n')).toContain('Aún no hay actividad');
+    expect(cuenta(l, '┌')).toBe(0);
+    for (const x of l) expect([...x].length).toBe(ANCHO);
+  });
+
+  test('se adapta al alto: recorta el registro y no pasa del máximo', () => {
+    const alto = dibujar(ejemplo(AHORA), { ahora: AHORA, uso: USO, carpeta: 'mi-app', filasMax: 48 }).alto;
+    expect(alto).toBeLessThanOrEqual(48);
+    const completo = dibujar(ejemplo(AHORA), { ahora: AHORA, uso: USO, carpeta: 'mi-app' }).alto;
+    expect(completo).toBeGreaterThan(alto);
+  });
+
+  test('a ANSI: sin color no hay escapes; con color de 24 bits sí', () => {
+    const { filas } = dibujar(ejemplo(AHORA), { ahora: AHORA, uso: USO, carpeta: 'mi-app' });
+    expect(aAnsi(filas, 'none')).not.toContain('\x1b');
+    expect(aAnsi(filas, 'truecolor')).toContain('38;2;');
+    expect(aAnsi(filas, '256')).toContain('38;5;');
+  });
+
+  test('la caja del líder no corta sus cifras', () => {
+    const l = demo().join('\n');
+    expect(l).toMatch(/leídos 668k · escritos 12k/);
+    expect(l).not.toMatch(/escritos 1…/);
+    expect(l).toMatch(/pasos 24 · herramientas 1/);
+  });
+
+  test('cada consulta del asesor dice cuánto duró', () => {
+    expect(demo().some((x) => /duró 4 s/.test(x))).toBe(true);
+  });
+
+  test('si el asesor está configurado, lo nombra y lo pone en la orden', () => {
+    const l = texto(dibujar(ejemplo(AHORA), { ahora: AHORA, uso: USO, carpeta: 'app', asesorModelo: 'opus' }).filas);
+    expect(l.some((x) => x.includes('OPUS'))).toBe(true);
+    expect(l.some((x) => x.includes('claude --model sonnet --advisor opus'))).toBe(true);
+    expect(demo().some((x) => x.includes('--advisor'))).toBe(false);
+  });
+
+  test('abajo, el uso con barras y el modelo frente al recomendado', () => {
+    const conRec = registrarRecomendacion(registrarPaso(ejemplo(AHORA), { modelo: 'claude-opus-5-5', esfuerzo: 'high' }), { modelo: 'sonnet', esfuerzo: 'medium', motivo: 'x' });
+    const l = texto(dibujar(conRec, { ahora: AHORA, uso: USO, carpeta: 'app' }).filas);
+    expect(l.some((x) => /contexto +█+░* +31 %/.test(x) && /5 h +█*░+ +43 %/.test(x) && /semana +█+░* +60 %/.test(x))).toBe(true);
+    expect(l.some((x) => x.includes('modelo claude-opus-5-5 · high → recomendado: sonnet · medium'))).toBe(true);
+    const igual = registrarRecomendacion(registrarPaso(ejemplo(AHORA), { modelo: 'claude-sonnet-5-5', esfuerzo: 'medium' }), { modelo: 'sonnet', esfuerzo: 'medium', motivo: 'x' });
+    expect(texto(dibujar(igual, { ahora: AHORA, uso: USO, carpeta: 'app' }).filas).some((x) => x.includes('modelo claude-sonnet-5-5 · medium ✓'))).toBe(true);
+    for (const x of l) expect([...x].length).toBe(ANCHO);
+  });
+
+  test('una revisión externa sale en su caja a la derecha del líder, con su IA y modelo', () => {
+    const conRev = iniciarRevision(ejemplo(AHORA), { id: 'r1', ia: 'codex', modelo: 'gpt-6.1-sol', esfuerzo: 'high', at: AHORA - 45_000 });
+    const l = texto(dibujar(conRev, { ahora: AHORA, uso: USO, carpeta: 'app' }).filas);
+    expect(l.some((x) => x.includes('Sonnet 5.5 · sesión principal') && x.includes('REVISIÓN'))).toBe(true);
+    for (const t of ['Codex', 'gpt-6.1-sol', '◐ revisando', '■ codex · revisa']) expect(l.some((x) => x.includes(t))).toBe(true);
+    for (const x of l) expect([...x].length).toBe(ANCHO);
+    expect(texto(dibujar(ejemplo(AHORA), { ahora: AHORA, uso: USO, carpeta: 'app' }).filas).some((x) => x.includes('REVISIÓN'))).toBe(false);
+  });
+
+  test('si se le pasa el uso de Codex, lo enseña abajo con sus límites y cuándo fue', () => {
+    const codex = { modelo: 'gpt-6.1-sol', esfuerzo: 'low', leidos: 372_693, cache: 323_584, escritos: 3_899, limite5h: 1, limiteSemana: 14, actualizado: AHORA - 180_000 };
+    const l = texto(dibujar(ejemplo(AHORA), { ahora: AHORA, uso: USO, carpeta: 'app', codex }).filas);
+    const fila = l.find((x) => x.includes('codex gpt-6.1-sol'));
+    expect(fila).toBeTruthy();
+    expect(fila).toMatch(/leídos 373k · escritos 3.9k/);
+    expect(fila).toMatch(/5 h .* 1 %/);
+    expect(fila).toMatch(/semana .* 14 %/);
+    expect(fila).toMatch(/hace 3 min/);
+    const vacio = texto(dibujar(crear(), { ahora: AHORA, uso: null, carpeta: 'app', codex }).filas);
+    expect(vacio.some((x) => x.includes('codex gpt-6.1-sol'))).toBe(true);
+  });
+});
+

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