@johpaz/hive-sdk 0.1.6 → 0.2.0

package/test/browser-backend.test.ts

@@ -1,308 +0,0 @@
-/**
- * BrowserBackend — selección de backend y el WebViewBackend real.
- *
- * Los tests marcados como "vivos" abren un navegador de verdad y se saltan solos
- * donde no hay motor (sin Chrome y sin macOS). Los de selección son puros y
- * corren siempre: son los que evitan que un cambio de default mande el gateway
- * headless a un backend que necesita display.
- */
-
-process.env.HIVE_DB_PATH = ":memory:";
-
-import { describe, test, expect, beforeEach, afterEach, afterAll } from "bun:test";
-import {
-  resolveBackendKind,
-  isWebViewSupported,
-  resolveWebViewEngine,
-  findChrome,
-} from "../packages/core/src/tools/web/browser-backend.ts";
-import { WebViewBackend } from "../packages/core/src/tools/web/webview-backend.ts";
-
-const ORIGINAL_ENV = process.env.HIVE_BROWSER_BACKEND;
-
-afterEach(() => {
-  if (ORIGINAL_ENV === undefined) delete process.env.HIVE_BROWSER_BACKEND;
-  else process.env.HIVE_BROWSER_BACKEND = ORIGINAL_ENV;
-});
-
-// Una sola vez, al final del archivo: `closeAll()` mata TODOS los subprocesos de
-// navegador del proceso, así que dentro de un `afterAll` por bloque le arranca
-// Chrome de abajo al bloque siguiente ("Chrome killed by signal 9").
-afterAll(() => {
-  (globalThis as { Bun?: { WebView?: { closeAll?: () => void } } }).Bun?.WebView?.closeAll?.();
-});
-
-// ─── selección de backend ─────────────────────────────────────────────────────
-
-describe("resolveBackendKind", () => {
-  test("el default es agent-browser — es el único que corre headless sin Chrome", () => {
-    delete process.env.HIVE_BROWSER_BACKEND;
-    expect(resolveBackendKind(undefined)).toBe("agent-browser");
-  });
-
-  test("respeta la preferencia de config", () => {
-    delete process.env.HIVE_BROWSER_BACKEND;
-    expect(resolveBackendKind("webview")).toBe("webview");
-    expect(resolveBackendKind("agent-browser")).toBe("agent-browser");
-  });
-
-  test("HIVE_BROWSER_BACKEND pisa la config", () => {
-    process.env.HIVE_BROWSER_BACKEND = "webview";
-    expect(resolveBackendKind("agent-browser")).toBe("webview");
-
-    process.env.HIVE_BROWSER_BACKEND = "agent-browser";
-    expect(resolveBackendKind("webview")).toBe("agent-browser");
-  });
-
-  test("'auto' nunca elige webview si no hay motor disponible", () => {
-    delete process.env.HIVE_BROWSER_BACKEND;
-    const kind = resolveBackendKind("auto");
-    expect(kind).toBe(isWebViewSupported() ? "webview" : "agent-browser");
-  });
-
-  test("un valor desconocido cae al default en vez de romper", () => {
-    process.env.HIVE_BROWSER_BACKEND = "netscape";
-    expect(resolveBackendKind("webview")).toBe("agent-browser");
-  });
-});
-
-describe("detección de motor", () => {
-  test("resolveWebViewEngine devuelve webkit en macOS y chrome sólo si hay binario", () => {
-    const engine = resolveWebViewEngine();
-    if (process.platform === "darwin") {
-      expect(engine).toBe("webkit");
-    } else {
-      expect(engine).toBe(findChrome() ? "chrome" : null);
-    }
-  });
-
-  test("BUN_CHROME_PATH gana sobre la búsqueda en rutas estándar", () => {
-    const previous = process.env.BUN_CHROME_PATH;
-    process.env.BUN_CHROME_PATH = "/ruta/propia/chrome";
-    try {
-      expect(findChrome()).toBe("/ruta/propia/chrome");
-    } finally {
-      if (previous === undefined) delete process.env.BUN_CHROME_PATH;
-      else process.env.BUN_CHROME_PATH = previous;
-    }
-  });
-});
-
-// ─── WebViewBackend vivo ──────────────────────────────────────────────────────
-
-const LIVE = isWebViewSupported();
-// El charset va explícito: sin él el motor asume latin-1 y "botón" llega como
-// "botón". Una página real lo declara; una data: URL no.
-const page = (html: string) => `data:text/html;charset=utf-8,${encodeURIComponent(html)}`;
-
-describe.skipIf(!LIVE)("WebViewBackend (navegador real)", () => {
-  let backend: WebViewBackend;
-
-  beforeEach(() => {
-    backend = new WebViewBackend();
-  });
-
-  afterEach(() => {
-    backend.close();
-  });
-
-  test("navega y evalúa en la página", async () => {
-    await backend.navigate(page("<h1>hola mundo</h1>"));
-    expect(await backend.evaluate<string>("document.querySelector('h1').textContent")).toBe("hola mundo");
-  });
-
-  test("serializa operaciones concurrentes — WebView rechaza las solapadas", async () => {
-    // Sin la cola interna esto falla con
-    // "ERR_INVALID_STATE: a simple operation is already pending".
-    await backend.navigate(page("<p id=x>1</p>"));
-
-    const results = await Promise.all([
-      backend.evaluate("1 + 1"),
-      backend.evaluate("2 + 2"),
-      backend.evaluate("3 + 3"),
-      backend.evaluate("document.getElementById('x').textContent"),
-    ]);
-
-    expect(results).toEqual([2, 4, 6, "1"]);
-  });
-
-  test("una operación fallida no rompe la cola para las siguientes", async () => {
-    await backend.navigate(page("<h1>sigo viva</h1>"));
-
-    await expect(backend.evaluate("esto.no.existe()")).rejects.toThrow();
-    expect(await backend.evaluate<string>("document.querySelector('h1').textContent")).toBe("sigo viva");
-  });
-
-  test("click y fill operan por selector CSS", async () => {
-    await backend.navigate(
-      page(`<input id="i"><button id="b" onclick="document.getElementById('i').dataset.hit='1'">Go</button>`),
-    );
-
-    await backend.fill("#i", "texto nuevo");
-    expect(await backend.evaluate<string>("document.getElementById('i').value")).toBe("texto nuevo");
-
-    await backend.click("#b");
-    expect(await backend.evaluate<string>("document.getElementById('i').dataset.hit")).toBe("1");
-  });
-
-  test("fill reemplaza el contenido en vez de agregarlo", async () => {
-    await backend.navigate(page(`<input id="i" value="viejo">`));
-    await backend.fill("#i", "nuevo");
-    expect(await backend.evaluate<string>("document.getElementById('i').value")).toBe("nuevo");
-  });
-
-  test("typeIn y fill fallan claro cuando el selector no existe", async () => {
-    await backend.navigate(page("<h1>x</h1>"));
-    await expect(backend.typeIn("#no-existe", "x")).rejects.toThrow(/no encontrado/);
-    await expect(backend.fill("#no-existe", "x")).rejects.toThrow(/no encontrado/);
-  });
-
-  test("la navegación hacia atrás usa goBack — los tipos de bun-types dicen back()", async () => {
-    await backend.navigate(page("<h1>primera</h1>"));
-    await backend.navigate(page("<h1>segunda</h1>"));
-    expect(await backend.evaluate<string>("document.querySelector('h1').textContent")).toBe("segunda");
-
-    await backend.back();
-    expect(await backend.evaluate<string>("document.querySelector('h1').textContent")).toBe("primera");
-  });
-
-  test("screenshot devuelve un PNG en base64", async () => {
-    await backend.navigate(page("<h1>foto</h1>"));
-    const shot = await backend.screenshot();
-    expect(shot.length).toBeGreaterThan(100);
-    // Cabecera PNG (\x89PNG) en base64.
-    expect(shot.startsWith("iVBORw0KGgo")).toBe(true);
-  });
-
-  test("screenshotElement recorta al elemento pedido", async () => {
-    await backend.navigate(
-      page(`<div id="chico" style="width:80px;height:40px;background:red"></div>`),
-    );
-    const shot = await backend.screenshotElement("#chico");
-    expect(shot.startsWith("iVBORw0KGgo")).toBe(true);
-    // El recorte tiene que pesar menos que la captura del viewport entero.
-    expect(shot.length).toBeLessThan((await backend.screenshot()).length);
-  });
-
-  test("screenshotElement falla claro si el elemento no existe", async () => {
-    await backend.navigate(page("<h1>x</h1>"));
-    await expect(backend.screenshotElement("#fantasma")).rejects.toThrow(/no visible o inexistente/);
-  });
-});
-
-// ─── snapshot sintetizado ─────────────────────────────────────────────────────
-
-describe.skipIf(!LIVE)("WebViewBackend.snapshot", () => {
-  let backend: WebViewBackend;
-
-  beforeEach(() => {
-    backend = new WebViewBackend();
-  });
-
-  afterEach(() => {
-    backend.close();
-  });
-
-  test("reproduce el formato de agent-browser: rol, nombre y ref", async () => {
-    await backend.navigate(page(`<h1>Example Domain</h1><p><a href="/x">Learn more</a></p>`));
-    const snapshot = await backend.snapshot({ compact: true, depth: 3 });
-
-    expect(snapshot).toContain('- heading "Example Domain" [level=1, ref=e1]');
-    expect(snapshot).toContain('link "Learn more"');
-    expect(snapshot).toMatch(/ref=e\d+/);
-  });
-
-  test("anida los hijos bajo el padre que emitió línea", async () => {
-    await backend.navigate(page(`<p>Intro <a href="/x">un link</a></p>`));
-    const snapshot = await backend.snapshot();
-
-    const linea = snapshot.split("\n").find((l) => l.includes("link"));
-    expect(linea?.startsWith("  ")).toBe(true);
-  });
-
-  test("los divs de maquetado no generan sangría — el árbol no se hunde", async () => {
-    await backend.navigate(
-      page(`<div><div><div><div><button>Enviar</button></div></div></div></div>`),
-    );
-    const snapshot = await backend.snapshot({ depth: 3 });
-
-    // Cuatro divs de por medio y el botón sigue en el nivel raíz.
-    expect(snapshot).toBe('- button "Enviar" [ref=e1]');
-  });
-
-  test("ignora script, style y lo oculto", async () => {
-    await backend.navigate(
-      page(`<script>var secreto=1</script><style>.x{}</style>
-            <div hidden><a href="/h">oculto</a></div>
-            <div style="display:none"><a href="/d">tampoco</a></div>
-            <div aria-hidden="true"><a href="/a">ni este</a></div>
-            <a href="/v">visible</a>`),
-    );
-    const snapshot = await backend.snapshot();
-
-    expect(snapshot).toContain("visible");
-    expect(snapshot).not.toContain("secreto");
-    expect(snapshot).not.toContain("oculto");
-    expect(snapshot).not.toContain("tampoco");
-    expect(snapshot).not.toContain("ni este");
-  });
-
-  test("toma el nombre accesible de aria-label, alt y placeholder", async () => {
-    await backend.navigate(
-      page(`<button aria-label="Cerrar ventana"></button>
-            <img src="x.png" alt="Un gato">
-            <input placeholder="Tu correo">`),
-    );
-    const snapshot = await backend.snapshot();
-
-    expect(snapshot).toContain("Cerrar ventana");
-    expect(snapshot).toContain("Un gato");
-    expect(snapshot).toContain("Tu correo");
-  });
-
-  test("interactiveOnly deja sólo lo accionable", async () => {
-    await backend.navigate(
-      page(`<h1>Un título</h1><p>Un párrafo largo</p><a href="/x">Un link</a><button>Un botón</button>`),
-    );
-    const snapshot = await backend.snapshot({ interactiveOnly: true });
-
-    expect(snapshot).toContain("Un link");
-    expect(snapshot).toContain("Un botón");
-    expect(snapshot).not.toContain("Un título");
-    expect(snapshot).not.toContain("Un párrafo largo");
-  });
-
-  test("depth corta la profundidad de lo que sí anida", async () => {
-    // La profundidad cuenta niveles *emitidos*, no nodos del DOM: por eso hace
-    // falta un ancestro con nombre propio (el nav) para que el link baje un nivel.
-    await backend.navigate(page(`<nav aria-label="Menú"><a href="/x">hondo</a></nav>`));
-
-    expect(await backend.snapshot({ depth: 1 })).not.toContain("hondo");
-    expect(await backend.snapshot({ depth: 5 })).toContain("hondo");
-  });
-
-  test("marca los atributos de estado del control", async () => {
-    await backend.navigate(
-      page(`<input type="checkbox" aria-label="Acepto" checked>
-            <button disabled aria-label="Enviar">x</button>`),
-    );
-    const snapshot = await backend.snapshot();
-
-    expect(snapshot).toContain("checked");
-    expect(snapshot).toContain("disabled");
-  });
-
-  test("un DOM enorme se trunca en vez de comerse el contexto", async () => {
-    const filas = Array.from({ length: 4000 }, (_, i) => `<p>fila número ${i} con texto de relleno</p>`).join("");
-    await backend.navigate(page(`<div>${filas}</div>`));
-
-    const snapshot = await backend.snapshot();
-    expect(snapshot.length).toBeLessThan(21_000);
-    expect(snapshot).toContain("snapshot truncado");
-  });
-
-  test("una página vacía devuelve string vacío, no una excepción", async () => {
-    await backend.navigate(page("<body></body>"));
-    expect(await backend.snapshot()).toBe("");
-  });
-});

package/test/catalog-agents-stay-enabled.test.ts

@@ -1,117 +0,0 @@
-/**
- * A catalog persona is a capability of the whole hive, not a disposable
- * worker: nothing automatic may switch one off. Disabling is the user's call,
- * from the Agents UI (PUT /api/agents/:id). Uses HIVE_DB_PATH=":memory:".
- */
-
-process.env.HIVE_DB_PATH = ":memory:";
-
-import { describe, test, expect, beforeEach, afterEach } from "bun:test";
-import { closeHiveDb } from "../packages/core/src/storage/hivedb";
-import { ensureHiveDb } from "../packages/core/src/storage/bootstrap";
-import { col } from "../packages/core/src/storage/hive";
-import type { AgentDoc, AgentProposalDoc } from "../packages/core/src/storage/collections";
-import { runCurator } from "../packages/core/src/agent/curator";
-import { agentArchiveTool } from "../packages/core/src/tools/agents";
-import { CATALOG_AGENT_IDS } from "../packages/core/src/agent/agent-catalog";
-
-const VICTIM = "workspace_file_operator";
-
-beforeEach(async () => {
-  closeHiveDb();
-  await ensureHiveDb();
-});
-
-afterEach(() => {
-  closeHiveDb();
-});
-
-async function agent(id: string): Promise<AgentDoc> {
-  const entry = await (await col<AgentDoc>("agents")).get(id);
-  if (!entry) throw new Error(`agent not found: ${id}`);
-  return entry.doc;
-}
-
-async function setCounters(id: string, helpful: number, harmful: number): Promise<void> {
-  const agentsCol = await col<AgentDoc>("agents");
-  const entry = (await agentsCol.get(id))!;
-  await agentsCol.put(id, { ...entry.doc, helpful_count: helpful, harmful_count: harmful }, { expectedVersion: entry.version });
-}
-
-describe("curator", () => {
-  test("never disables a catalog agent, however bad its ACE counters are", async () => {
-    await setCounters(VICTIM, 0, 25);
-
-    await runCurator();
-
-    expect((await agent(VICTIM)).enabled).toBe(true);
-  });
-
-  test("raises a reviewable proposal instead of applying the change", async () => {
-    await setCounters(VICTIM, 0, 5);
-
-    await runCurator();
-
-    const proposals = (await (await col<AgentProposalDoc>("agentProposals")).findBy("agent_id", VICTIM)).map(e => e.doc);
-    expect(proposals).toHaveLength(1);
-    expect(proposals[0].type).toBe("disable_agent");
-    expect(proposals[0].status).toBe("proposed");
-  });
-
-  test("does not archive catalog agents that were never used", async () => {
-    // Seeded with lastTraceAt=null, which the inactivity cutoff reads as epoch 0
-    expect((await agent(VICTIM)).lastTraceAt).toBeNull();
-
-    await runCurator();
-
-    for (const id of CATALOG_AGENT_IDS) {
-      expect((await agent(id)).status).not.toBe("archived");
-    }
-  });
-
-  test("repairs a catalog agent archived by an older release on boot", async () => {
-    const agentsCol = await col<AgentDoc>("agents");
-    const existing = (await agentsCol.get(VICTIM))!;
-    await agentsCol.put(
-      VICTIM,
-      { ...existing.doc, status: "archived" },
-      { expectedVersion: existing.version },
-    );
-
-    await ensureHiveDb();
-
-    expect((await agent(VICTIM)).status).toBe("idle");
-  });
-
-  test("does not archive an inactive worker automatically", async () => {
-    const agentsCol = await col<AgentDoc>("agents");
-    const stale = { ...(await agent(VICTIM)), id: "stale-worker", source: "user" as const, lastTraceAt: 1 };
-    await agentsCol.put(stale.id, stale);
-
-    await runCurator();
-
-    expect((await agent("stale-worker")).status).not.toBe("archived");
-    expect((await agent("stale-worker")).enabled).toBe(true);
-  });
-});
-
-describe("agent_archive tool", () => {
-  test("refuses to archive a catalog agent", async () => {
-    const result = await agentArchiveTool.execute({ agentId: VICTIM }) as { ok: boolean; error?: string };
-
-    expect(result.ok).toBe(false);
-    expect(result.error).toContain("catalog agent");
-    expect((await agent(VICTIM)).enabled).toBe(true);
-  });
-
-  test("still archives a worker created by the coordinator", async () => {
-    const agentsCol = await col<AgentDoc>("agents");
-    const worker = { ...(await agent(VICTIM)), id: "spawned-worker", source: "user" as const };
-    await agentsCol.put(worker.id, worker);
-
-    const result = await agentArchiveTool.execute({ agentId: "spawned-worker" }) as { ok: boolean };
-
-    expect(result.ok).toBe(true);
-    expect((await agent("spawned-worker")).enabled).toBe(false);
-  });
-});

package/test/causal-events.test.ts

@@ -1,117 +0,0 @@
-/**
- * Track B feasibility proof: HiveDB's subscribe()/events() (wrapped by
- * watchCausalEvents()) actually works for hive's use case — forward
- * delivery, pattern filtering, and clean shutdown — and explicitly proves
- * the "no historical replay" constraint documented in causal-events.ts
- * (subscribe()/events() are a pure in-process pub/sub, not a durable read
- * of the log — see hiveBD's reactive.rs).
- */
-
-process.env.HIVE_DB_PATH = ":memory:";
-
-import { describe, test, expect, beforeEach, afterEach } from "bun:test";
-import { closeHiveDb, getHiveDb } from "../packages/core/src/storage/hivedb";
-import { ensureHiveDb } from "../packages/core/src/storage/bootstrap";
-import { resetBootId } from "../packages/core/src/storage/boot-id";
-import { watchCausalEvents } from "../packages/core/src/storage/causal-events";
-import type { CausalEvent } from "../packages/core/src/storage/causal-events";
-
-beforeEach(async () => {
-  closeHiveDb();
-  resetBootId();
-  await ensureHiveDb();
-});
-
-afterEach(() => {
-  closeHiveDb();
-});
-
-describe("causal-events: watchCausalEvents()", () => {
-  test("delivers only events matching the pattern, forward, in order", async () => {
-    const stream = await watchCausalEvents({ agentId: "agent-x" });
-    const db = await getHiveDb();
-
-    await db.append({
-      agentId: "agent-x",
-      streamId: "s1",
-      kind: "IntentLogged",
-      payload: JSON.stringify({ actor: "agent-x", intent: "one" }),
-    });
-    await db.append({
-      agentId: "agent-other",
-      streamId: "s2",
-      kind: "IntentLogged",
-      payload: JSON.stringify({ actor: "agent-other", intent: "should be filtered out" }),
-    });
-    await db.append({
-      agentId: "agent-x",
-      streamId: "s1",
-      kind: "StateTransition",
-      payload: JSON.stringify({ description: "three" }),
-    });
-
-    const received: CausalEvent[] = [];
-    const iterator = stream[Symbol.asyncIterator]();
-    received.push((await iterator.next()).value!);
-    received.push((await iterator.next()).value!);
-    stream.close();
-
-    expect(received.length).toBe(2);
-    expect(received.every((e) => e.agentId === "agent-x")).toBe(true);
-    expect(received.map((e) => e.kindTag)).toEqual(["IntentLogged", "StateTransition"]);
-  });
-
-  test("has no historical replay: events appended before subscribing are never delivered", async () => {
-    const db = await getHiveDb();
-    await db.append({
-      agentId: "agent-y",
-      streamId: "s1",
-      kind: "IntentLogged",
-      payload: JSON.stringify({ actor: "agent-y", intent: "pre-existing, must not be delivered" }),
-    });
-
-    // Subscribe AFTER the append above.
-    const stream = await watchCausalEvents({ agentId: "agent-y" });
-    const iterator = stream[Symbol.asyncIterator]();
-
-    const raceResult = await Promise.race([
-      iterator.next().then((r) => ({ type: "event" as const, value: r.value })),
-      new Promise<{ type: "timeout" }>((resolve) => setTimeout(() => resolve({ type: "timeout" }), 200)),
-    ]);
-    expect(raceResult.type).toBe("timeout");
-
-    // Prove the stream itself still works for a genuinely new event —
-    // distinguishes "no replay" from "the stream is just broken".
-    await db.append({
-      agentId: "agent-y",
-      streamId: "s1",
-      kind: "StateTransition",
-      payload: JSON.stringify({ description: "post-subscribe, must be delivered" }),
-    });
-    const { value: event } = await iterator.next();
-    expect(event?.kindTag).toBe("StateTransition");
-
-    stream.close();
-  });
-
-  test("close() ends the for-await loop cleanly and doesn't block a subsequent closeHiveDb()", async () => {
-    const stream = await watchCausalEvents({ agentId: "agent-z" });
-    const db = await getHiveDb();
-    await db.append({
-      agentId: "agent-z",
-      streamId: "s1",
-      kind: "IntentLogged",
-      payload: JSON.stringify({ actor: "agent-z", intent: "one" }),
-    });
-
-    const collected: CausalEvent[] = [];
-    for await (const event of stream) {
-      collected.push(event);
-      stream.close();
-    }
-
-    expect(collected.length).toBe(1);
-    // afterEach's closeHiveDb() must not hang/throw with this subscription
-    // closed-but-not-drained — implicitly verified by the test completing.
-  });
-});

package/test/compaction.test.ts

@@ -1,105 +0,0 @@
-/**
- * Pure-function tests for compaction.ts's cut-point and transcript-rendering
- * helpers — extracted so they're testable without a real LLM call
- * (compactThread() itself calls callLLM and needs network).
- */
-
-import { describe, test, expect } from "bun:test";
-import { findCompactionCutIndex, renderTranscript } from "../packages/core/src/agent/compaction";
-import type { StoredMessage } from "../packages/core/src/agent/conversation-store";
-
-function msg(partial: Partial<StoredMessage> & Pick<StoredMessage, "id" | "role" | "content">): StoredMessage {
-  return {
-    thread_id: "t",
-    channel: "webchat",
-    source: "message",
-    tool_calls_json: null,
-    tool_call_id: null,
-    reasoning_content: null,
-    content_multimodal: null,
-    token_count: 1,
-    created_at: Date.now(),
-    ...partial,
-  };
-}
-
-describe("findCompactionCutIndex", () => {
-  test("finds a clean user-turn boundary near the end of the history", () => {
-    const rows: StoredMessage[] = [
-      msg({ id: 1, role: "user", content: "a" }),
-      msg({ id: 2, role: "assistant", content: "b" }),
-      msg({ id: 3, role: "user", content: "c" }),
-      msg({ id: 4, role: "assistant", content: "d" }),
-      msg({ id: 5, role: "user", content: "e" }),
-      msg({ id: 6, role: "assistant", content: "f" }),
-      msg({ id: 7, role: "user", content: "g" }),
-    ];
-
-    // keepLastN=3 -> naive cut at index 4 (rows[4].role === "user") — already clean.
-    expect(findCompactionCutIndex(rows, 3)).toBe(4);
-  });
-
-  test("walks back to the nearest user turn when the naive cut lands on assistant", () => {
-    const rows: StoredMessage[] = [
-      msg({ id: 1, role: "user", content: "a" }),
-      msg({ id: 2, role: "user", content: "b" }), // internal event, still role:user
-      msg({ id: 3, role: "assistant", content: "c" }),
-      msg({ id: 4, role: "assistant", content: "d" }),
-    ];
-
-    // keepLastN=1 -> naive cut at index 3 (assistant) -> walk back to index 1 (user).
-    expect(findCompactionCutIndex(rows, 1)).toBe(1);
-  });
-
-  test("a tail of internal events (role:user) does not block the cut point", () => {
-    const rows: StoredMessage[] = [
-      msg({ id: 1, role: "user", content: "a" }),
-      msg({ id: 2, role: "assistant", content: "b" }),
-      msg({ id: 3, role: "user", content: "El agente completó la tarea X.", source: "task_complete" }),
-      msg({ id: 4, role: "user", content: "El agente completó la tarea Y.", source: "delegation_summary" }),
-    ];
-
-    // keepLastN=2 -> naive cut at index 2, which IS a user turn (the internal
-    // event) — before source-based framing existed, this was persisted as
-    // role:"system" and would have blocked the cut entirely.
-    expect(findCompactionCutIndex(rows, 2)).toBe(2);
-  });
-
-  test("returns 0 when no clean boundary exists (caller should skip compaction)", () => {
-    const rows: StoredMessage[] = [
-      msg({ id: 1, role: "assistant", content: "a" }),
-      msg({ id: 2, role: "assistant", content: "b" }),
-    ];
-
-    expect(findCompactionCutIndex(rows, 1)).toBe(0);
-  });
-});
-
-describe("renderTranscript", () => {
-  test("labels normal rows by role", () => {
-    const rows: StoredMessage[] = [
-      msg({ id: 1, role: "user", content: "hola" }),
-      msg({ id: 2, role: "assistant", content: "¿en qué te ayudo?" }),
-    ];
-
-    const transcript = renderTranscript(rows);
-    expect(transcript).toContain("[USER]: hola");
-    expect(transcript).toContain("[ASSISTANT]: ¿en qué te ayudo?");
-  });
-
-  test("labels internal-source rows [EVENTO INTERNO], never [USER]", () => {
-    const rows: StoredMessage[] = [
-      msg({ id: 1, role: "user", content: "El agente completó la tarea X.", source: "task_complete" }),
-    ];
-
-    const transcript = renderTranscript(rows);
-    expect(transcript).toContain("[EVENTO INTERNO]: El agente completó la tarea X.");
-    expect(transcript).not.toContain("[USER]");
-  });
-
-  test("truncates each message to maxMsgChars", () => {
-    const rows: StoredMessage[] = [msg({ id: 1, role: "user", content: "x".repeat(500) })];
-    const transcript = renderTranscript(rows, 10);
-    expect(transcript).toBe(`[USER]: ${"x".repeat(10)}`);
-  });
-});