@johpaz/hive-sdk 0.1.5 → 0.2.0

package/test/minimal-loadout.test.ts

@@ -1,78 +0,0 @@
-/**
- * The coordinator starts every turn with MINIMAL_TOOLS and the skills derived
- * from it. Everything else is discovered, and discovery injects a tool together
- * with the skills that document it (agent-loop.ts).
- *
- * So an always-injected skill that teaches a tool outside the loadout is pure
- * cost: the agent reads instructions for something it cannot call, and gets the
- * same skill again later when it discovers the tool. That is exactly what had
- * drifted — 3 of the 4 hand-listed "minimal" skills were in that state — hence
- * the derivation in minimal-loadout.ts and this test.
- *
- * Uses HIVE_DB_PATH=":memory:".
- */
-
-process.env.HIVE_DB_PATH = ":memory:";
-
-import { describe, test, expect, beforeAll, afterAll } from "bun:test";
-import { closeHiveDb } from "../packages/core/src/storage/hivedb";
-import { ensureHiveDb } from "../packages/core/src/storage/bootstrap";
-import { createAllTools } from "../packages/core/src/tools/index";
-import { getMinimalSkills } from "../packages/core/src/agent/skill-selector";
-import {
-  MINIMAL_TOOLS,
-  isMinimalSkill,
-  parseSkillTools,
-} from "../packages/core/src/agent/minimal-loadout";
-
-beforeAll(async () => {
-  closeHiveDb();
-  await ensureHiveDb();
-});
-
-afterAll(() => {
-  closeHiveDb();
-});
-
-describe("minimal loadout", () => {
-  test("every minimal tool is a real executor", () => {
-    const executors = new Set(createAllTools({ tools: {} } as never).map((t) => t.name));
-    const missing = [...MINIMAL_TOOLS].filter((name) => !executors.has(name)).sort();
-    expect(missing).toEqual([]);
-  });
-
-  test("no minimal skill teaches a tool outside the loadout", async () => {
-    const offenders = (await getMinimalSkills())
-      .map((skill) => ({
-        name: skill.name,
-        outside: parseSkillTools(skill.tools).filter((t) => !MINIMAL_TOOLS.has(t)),
-      }))
-      .filter((s) => s.outside.length > 0);
-    expect(offenders).toEqual([]);
-  });
-
-  test("the derivation actually selects something", async () => {
-    const names = (await getMinimalSkills()).map((s) => s.name);
-    // capability_discovery documents search_knowledge and nothing else, so it
-    // qualifies by construction. If this ever empties out, the loadout and the
-    // bundled skills have drifted apart again.
-    expect(names).toContain("capability_discovery");
-  });
-
-  test("the rule rejects skills that reach outside the loadout", () => {
-    expect(isMinimalSkill("search_knowledge")).toBe(true);
-    expect(isMinimalSkill("task_delegate, agent_find, task_status")).toBe(true);
-    expect(isMinimalSkill("search_knowledge, memory_write")).toBe(false);
-    expect(isMinimalSkill("a2ui_create_surface")).toBe(false);
-    expect(isMinimalSkill("")).toBe(false); // no anchor to the loadout
-  });
-
-  test("skills left out still reach the agent through discovery", async () => {
-    // They are not lost, just not always-on: agent-loop injects a skill when
-    // search_knowledge surfaces any tool the skill declares.
-    const minimal = new Set((await getMinimalSkills()).map((s) => s.name));
-    expect(minimal.has("memory_manager")).toBe(false);
-    expect(minimal.has("a2ui_dashboard")).toBe(false);
-    expect(minimal.has("task_orchestrator")).toBe(false);
-  });
-});

package/test/model-catalog.test.ts

@@ -1,105 +0,0 @@
-// Importar el seed arrastra los módulos de storage, que resuelven la ruta de la
-// BD al cargarse. Sin esto el archivo podía dejar apuntando la BD real.
-process.env.HIVE_DB_PATH = ":memory:";
-
-import { describe, expect, test } from "bun:test";
-import { SEED_DATA } from "../packages/core/src/storage/seed";
-import { catalogModelKey, wireModelId, isResellerProvider } from "../packages/core/src/storage/model-id";
-
-/**
- * Guardas del catálogo de modelos.
- *
- * La colección `models` se indexa por una sola clave, así que dos entradas que
- * colapsen a la misma la pisan entre sí — pasó de verdad con `z-ai/glm-5.2`,
- * sembrado a la vez en NVIDIA NIM y en OpenRouter, donde una fila desaparecía en
- * silencio. Y un modelo LLM sin precio se reporta como $0 en el dashboard, que es
- * indistinguible de un endpoint realmente gratuito.
- */
-describe("catálogo de modelos (SEED_DATA.models)", () => {
-  test("ninguna entrada colapsa a la misma clave de BD", () => {
-    const seen = new Map<string, string>();
-    const collisions: string[] = [];
-
-    for (const model of SEED_DATA.models) {
-      const key = catalogModelKey(model.providerId, model.id);
-      const previous = seen.get(key);
-      if (previous) {
-        collisions.push(`${key} ← ${previous} y ${model.providerId}/${model.id}`);
-      }
-      seen.set(key, `${model.providerId}/${model.id}`);
-    }
-
-    expect(collisions).toEqual([]);
-  });
-
-  test("todo modelo llm trae precio de entrada y de salida", () => {
-    const unpriced = SEED_DATA.models
-      .filter((m) => m.modelType === "llm")
-      .filter((m) => m.inputPer1M === undefined || m.outputPer1M === undefined)
-      .map((m) => `${m.providerId}/${m.id}`);
-
-    expect(unpriced).toEqual([]);
-  });
-
-  test("los precios son números no negativos", () => {
-    const invalid = SEED_DATA.models
-      .filter((m) => m.modelType === "llm")
-      .filter((m) => !(typeof m.inputPer1M === "number" && m.inputPer1M >= 0)
-        || !(typeof m.outputPer1M === "number" && m.outputPer1M >= 0))
-      .map((m) => `${m.providerId}/${m.id}`);
-
-    expect(invalid).toEqual([]);
-  });
-
-  test("todo modelo apunta a un provider sembrado", () => {
-    const providerIds = new Set(SEED_DATA.providers.map((p) => p.id));
-    const orphans = SEED_DATA.models
-      .filter((m) => !providerIds.has(m.providerId))
-      .map((m) => `${m.providerId}/${m.id}`);
-
-    expect(orphans).toEqual([]);
-  });
-});
-
-describe("catalogModelKey / wireModelId", () => {
-  test("los revendedores prefijan y los propietarios no", () => {
-    expect(catalogModelKey("nvidia", "z-ai/glm-5.2")).toBe("nvidia/z-ai/glm-5.2");
-    expect(catalogModelKey("openrouter", "z-ai/glm-5.2")).toBe("openrouter/z-ai/glm-5.2");
-    expect(catalogModelKey("anthropic", "claude-opus-5")).toBe("claude-opus-5");
-    expect(catalogModelKey("z-ai", "glm-5.2")).toBe("glm-5.2");
-    // ModelScope revende modelos de terceros (Qwen/, deepseek-ai/, zai-org/),
-    // que se solapan con los de NVIDIA y OpenRouter.
-    expect(catalogModelKey("modelscope", "Qwen/Qwen3.5-397B-A17B")).toBe("modelscope/Qwen/Qwen3.5-397B-A17B");
-    expect(wireModelId("modelscope", "modelscope/Qwen-Ambassador/Qwen3.8-Max")).toBe("Qwen-Ambassador/Qwen3.8-Max");
-  });
-
-  test("`id` en el catálogo es siempre el nombre del cable, no la clave ya prefijada", () => {
-    // No es idempotente a propósito: aplicarlo dos veces prefija dos veces. Un
-    // atajo `startsWith` para evitarlo rompía los modelos cuyo namespace propio
-    // coincide con el id del provider (ver el caso de abajo).
-    expect(catalogModelKey("opencode-go", "glm-5.1")).toBe("opencode-go/glm-5.1");
-    for (const model of SEED_DATA.models) {
-      expect(model.id.startsWith(`${model.providerId}/${model.providerId}/`)).toBe(false);
-    }
-  });
-
-  test("un modelo propio del revendedor conserva su namespace tras el strip", () => {
-    // El nombre de cable de NVIDIA para su Nemotron ya empieza con "nvidia/",
-    // así que la clave lleva el prefijo dos veces a propósito.
-    const key = catalogModelKey("nvidia", "nvidia/nemotron-3-super-120b-a12b");
-    expect(key).toBe("nvidia/nvidia/nemotron-3-super-120b-a12b");
-    expect(wireModelId("nvidia", key)).toBe("nvidia/nemotron-3-super-120b-a12b");
-  });
-
-  test("wireModelId revierte catalogModelKey para todo el catálogo", () => {
-    for (const model of SEED_DATA.models) {
-      const key = catalogModelKey(model.providerId, model.id);
-      expect(wireModelId(model.providerId, key)).toBe(model.id);
-    }
-  });
-
-  test("wireModelId no toca a los providers propietarios", () => {
-    expect(isResellerProvider("anthropic")).toBe(false);
-    expect(wireModelId("anthropic", "claude-opus-5")).toBe("claude-opus-5");
-  });
-});

package/test/preload.ts

@@ -1,12 +0,0 @@
-/**
- * Preload de la suite de tests.
- *
- * Cada archivo de test pone `process.env.HIVE_DB_PATH = ":memory:"` en su primera
- * línea, pero los `import` de ESM se evalúan ANTES que cualquier sentencia del
- * módulo: si algo de la cadena de imports resuelve la ruta de la BD al cargarse,
- * la asignación llega tarde y la suite termina abriendo la base real del usuario
- * (~/.hive/data/hivedb), escribiéndole contadores y filtrando estado entre
- * archivos. Un preload corre antes que todo, así que acá sí gana.
- */
-
-process.env.HIVE_DB_PATH ||= ":memory:";

package/test/reflector.test.ts

@@ -1,320 +0,0 @@
-/**
- * Reflector tests: local trace-batch analysis, plus the G9 causalLog path
- * where per-tool insights (failure count, avg latency) come from HiveDB's
- * whole-history toolStats() instead of just the current batch of traces.
- */
-
-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 { col, nextId } from "../packages/core/src/storage/hive";
-import type { TraceDoc, ReflectionDoc } from "../packages/core/src/storage/collections";
-import { runReflector } from "../packages/core/src/agent/reflector";
-
-async function seedTrace(overrides: Partial<TraceDoc>) {
-  const tracesCol = await col<TraceDoc>("traces");
-  const id = await nextId("traces");
-  await tracesCol.put(id, {
-    id,
-    thread_id: "thread-1",
-    agent_id: "agent-1",
-    agent_name: "Agent 1",
-    tool_used: null,
-    input_summary: "input",
-    output_summary: "output",
-    success: true,
-    error_message: null,
-    duration_ms: null,
-    tokens_used: null,
-    created_at: Date.now(),
-    ...overrides,
-  });
-  return id;
-}
-
-beforeEach(async () => {
-  closeHiveDb();
-  resetBootId();
-  await ensureHiveDb();
-});
-
-afterEach(() => {
-  closeHiveDb();
-  delete process.env.HIVE_CAUSAL_LOG;
-});
-
-describe("reflector: local trace-batch analysis (causalLog disabled)", () => {
-  test("failure_pattern insight uses the batch-local failure count", async () => {
-    for (let i = 0; i < 4; i++) {
-      await seedTrace({ tool_used: "flaky_tool", success: false });
-    }
-    for (let i = 0; i < 6; i++) {
-      await seedTrace({ tool_used: "ok_tool", success: true });
-    }
-
-    await runReflector();
-
-    const reflectionsCol = await col<ReflectionDoc>("reflections");
-    const all = await reflectionsCol.scan({});
-    const failureInsight = all.find((e) => e.doc.insight_type === "failure_pattern");
-    expect(failureInsight).toBeDefined();
-    expect(failureInsight!.doc.description).toContain("flaky_tool");
-    expect(failureInsight!.doc.description).toContain("4 times");
-  });
-});
-
-describe("reflector: G9 causal event log (causalLog enabled)", () => {
-  test("failure_pattern insight uses toolStats().errors from the whole event log, not just this batch", async () => {
-    process.env.HIVE_CAUSAL_LOG = "true";
-    const db = await getHiveDb();
-
-    // 6 historical ToolCall errors for "flaky_tool" — more than the 4 failures
-    // present in this batch of traces.
-    for (let i = 0; i < 6; i++) {
-      await db.append({
-        agentId: "agent-1",
-        streamId: "stream-history",
-        kind: "ToolCall",
-        payload: JSON.stringify({ tool: "flaky_tool", outcome: { Err: `boom-${i}` } }),
-      });
-    }
-
-    for (let i = 0; i < 4; i++) {
-      await seedTrace({ tool_used: "flaky_tool", success: false });
-    }
-    for (let i = 0; i < 6; i++) {
-      await seedTrace({ tool_used: "ok_tool", success: true });
-    }
-
-    await runReflector();
-
-    const reflectionsCol = await col<ReflectionDoc>("reflections");
-    const all = await reflectionsCol.scan({});
-    const failureInsight = all.find((e) => e.doc.insight_type === "failure_pattern");
-    expect(failureInsight).toBeDefined();
-    // 6 from the event log's full history, not 4 from this batch alone
-    expect(failureInsight!.doc.description).toContain("6 times");
-  });
-
-  test("optimization (slow tool) insight uses toolStats().totalLatencyMs/invocations", async () => {
-    process.env.HIVE_CAUSAL_LOG = "true";
-    const db = await getHiveDb();
-
-    // 3 historical ToolCall events for "slow_tool" with a high average latency
-    // (12000ms), distinct from the batch's own (lower) durations.
-    for (let i = 0; i < 3; i++) {
-      await db.append({
-        agentId: "agent-1",
-        streamId: "stream-history",
-        kind: "ToolCall",
-        payload: JSON.stringify({ tool: "slow_tool", latency_ms: 12000, outcome: "Ok" }),
-      });
-    }
-
-    for (let i = 0; i < 3; i++) {
-      await seedTrace({ tool_used: "slow_tool", success: true, duration_ms: 6000 });
-    }
-    for (let i = 0; i < 7; i++) {
-      await seedTrace({ tool_used: "ok_tool", success: true });
-    }
-
-    await runReflector();
-
-    const reflectionsCol = await col<ReflectionDoc>("reflections");
-    const all = await reflectionsCol.scan({});
-    const slowInsight = all.find(
-      (e) => e.doc.insight_type === "optimization" && e.doc.description.includes("slow_tool")
-    );
-    expect(slowInsight).toBeDefined();
-    // avg from toolStats (12000ms), not from the batch's own durations (6000ms)
-    expect(slowInsight!.doc.description).toContain("12000ms");
-  });
-});
-
-describe("reflector: G9 causal-thread evaluation (evaluateHarness)", () => {
-  test("a stream with a repeated tool-call failure produces root_cause and learning_proposal insights", async () => {
-    process.env.HIVE_CAUSAL_LOG = "true";
-    const db = await getHiveDb();
-
-    // Build a realistic causal thread: Intent -> Decision -> 3x ToolCall Err
-    // (same tool + message), mirroring exactly what agent-loop.ts emits and
-    // matching the 3-repetition threshold hiveBD's errorLoop detector requires.
-    const streamId = "stream-rootcause-1";
-    const intentSeq = await db.append({
-      agentId: "agent-1",
-      streamId,
-      kind: "IntentLogged",
-      payload: JSON.stringify({ actor: "agent-1", intent: "deploy the checkout service" }),
-    });
-    const decisionSeq = await db.append({
-      agentId: "agent-1",
-      streamId,
-      kind: "StateTransition",
-      payload: JSON.stringify({ description: "Calling flaky_tool" }),
-      causation: intentSeq,
-    });
-    for (let i = 0; i < 3; i++) {
-      await db.append({
-        agentId: "agent-1",
-        streamId,
-        kind: "ToolCall",
-        payload: JSON.stringify({ tool: "flaky_tool", outcome: { Err: "boom" } }),
-        causation: decisionSeq,
-      });
-    }
-
-    await seedTrace({
-      tool_used: "flaky_tool",
-      success: false,
-      causal_stream_id: streamId,
-      input_summary: "deploy the checkout service",
-    });
-    for (let i = 0; i < 9; i++) {
-      await seedTrace({ tool_used: "ok_tool", success: true });
-    }
-
-    await runReflector();
-
-    const reflectionsCol = await col<ReflectionDoc>("reflections");
-    const all = await reflectionsCol.scan({});
-
-    const rootCause = all.find((e) => e.doc.insight_type === "root_cause");
-    expect(rootCause).toBeDefined();
-    expect(rootCause!.doc.description).toContain("flaky_tool");
-
-    const proposal = all.find((e) => e.doc.insight_type === "learning_proposal");
-    expect(proposal).toBeDefined();
-    expect(proposal!.doc.description.toLowerCase()).toContain("flaky_tool");
-    expect(proposal!.doc.confidence).toBeGreaterThanOrEqual(0.5);
-
-    // The mapped playbook categories from curator.ts (root_cause -> error_avoidance,
-    // learning_proposal -> response_quality) confirm the insights flowed all the
-    // way through to the playbook, not just into the reflections collection.
-    const playbookCol = await col<import("../packages/core/src/storage/collections").PlaybookDoc>("playbook");
-    const playbook = await playbookCol.scan({});
-    expect(playbook.some((e) => e.doc.source_reflection_id === rootCause!.id && e.doc.category === "error_avoidance")).toBe(true);
-    expect(playbook.some((e) => e.doc.source_reflection_id === proposal!.id && e.doc.category === "response_quality")).toBe(true);
-  });
-
-  test("a stream with no failures produces no root_cause or learning_proposal insights", async () => {
-    process.env.HIVE_CAUSAL_LOG = "true";
-    const db = await getHiveDb();
-
-    const streamId = "stream-clean-1";
-    const intentSeq = await db.append({
-      agentId: "agent-1",
-      streamId,
-      kind: "IntentLogged",
-      payload: JSON.stringify({ actor: "agent-1", intent: "read a file" }),
-    });
-    await db.append({
-      agentId: "agent-1",
-      streamId,
-      kind: "StateTransition",
-      payload: JSON.stringify({ description: "Calling read_file" }),
-      causation: intentSeq,
-    });
-
-    await seedTrace({ tool_used: "read_file", success: true, causal_stream_id: streamId });
-    for (let i = 0; i < 9; i++) {
-      await seedTrace({ tool_used: "ok_tool", success: true });
-    }
-
-    await runReflector();
-
-    const reflectionsCol = await col<ReflectionDoc>("reflections");
-    const all = await reflectionsCol.scan({});
-    expect(all.some((e) => e.doc.insight_type === "root_cause")).toBe(false);
-    expect(all.some((e) => e.doc.insight_type === "learning_proposal")).toBe(false);
-  });
-
-  test("a single tool-call failure produces exactly one root_cause insight, not two", async () => {
-    // Regression guard: harness.rs's find_root_cause() emits both
-    // evaluation.rootCause AND an equivalent finding{kind:"rootCause"} from the
-    // same resolution — analyzeCausalThreads() must only turn that into one
-    // insight, not two, per failure.
-    process.env.HIVE_CAUSAL_LOG = "true";
-    const db = await getHiveDb();
-
-    const streamId = "stream-single-failure";
-    const intentSeq = await db.append({
-      agentId: "agent-1",
-      streamId,
-      kind: "IntentLogged",
-      payload: JSON.stringify({ actor: "agent-1", intent: "deploy the checkout service" }),
-    });
-    const decisionSeq = await db.append({
-      agentId: "agent-1",
-      streamId,
-      kind: "StateTransition",
-      payload: JSON.stringify({ description: "Calling deploy_service" }),
-      causation: intentSeq,
-    });
-    await db.append({
-      agentId: "agent-1",
-      streamId,
-      kind: "ToolCall",
-      payload: JSON.stringify({ tool: "deploy_service", outcome: { Err: "boom" } }),
-      causation: decisionSeq,
-    });
-
-    await seedTrace({ tool_used: "deploy_service", success: false, causal_stream_id: streamId });
-    for (let i = 0; i < 9; i++) {
-      await seedTrace({ tool_used: "ok_tool", success: true });
-    }
-
-    await runReflector();
-
-    const reflectionsCol = await col<ReflectionDoc>("reflections");
-    const all = await reflectionsCol.scan({});
-    const rootCauseInsights = all.filter((e) => e.doc.insight_type === "root_cause");
-    expect(rootCauseInsights.length).toBe(1);
-  });
-
-  test("the same underlying root cause across two different streams reinforces one playbook rule instead of duplicating it", async () => {
-    process.env.HIVE_CAUSAL_LOG = "true";
-    const db = await getHiveDb();
-
-    async function seedFailingStream(streamId: string) {
-      const intentSeq = await db.append({
-        agentId: "agent-1",
-        streamId,
-        kind: "IntentLogged",
-        payload: JSON.stringify({ actor: "agent-1", intent: "deploy the checkout service" }),
-      });
-      const decisionSeq = await db.append({
-        agentId: "agent-1",
-        streamId,
-        kind: "StateTransition",
-        payload: JSON.stringify({ description: "Calling deploy_service" }),
-        causation: intentSeq,
-      });
-      await db.append({
-        agentId: "agent-1",
-        streamId,
-        kind: "ToolCall",
-        payload: JSON.stringify({ tool: "deploy_service", outcome: { Err: "boom" } }),
-        causation: decisionSeq,
-      });
-      await seedTrace({ tool_used: "deploy_service", success: false, causal_stream_id: streamId });
-    }
-
-    await seedFailingStream("stream-reinforce-a");
-    await seedFailingStream("stream-reinforce-b");
-    for (let i = 0; i < 8; i++) {
-      await seedTrace({ tool_used: "ok_tool", success: true });
-    }
-
-    await runReflector();
-
-    const playbookCol = await col<import("../packages/core/src/storage/collections").PlaybookDoc>("playbook");
-    const rootCauseRules = (await playbookCol.scan({})).filter((e) =>
-      e.doc.rule.includes('decision "Calling deploy_service"')
-    );
-    expect(rootCauseRules.length).toBe(1);
-    expect(rootCauseRules[0].doc.helpful_count).toBe(2);
-  });
-});

package/test/retention-cap.test.ts

@@ -1,91 +0,0 @@
-import { describe, it, expect, beforeEach } from "bun:test";
-process.env.HIVE_DB_PATH = ":memory:";
-
-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 { reconcileOnBoot } from "../packages/core/src/storage/reconcile";
-
-beforeEach(async () => {
-  await closeHiveDb();
-  await ensureHiveDb();
-});
-
-describe("retention cap in reconcileOnBoot", () => {
-  it("caps agentRuns to 500 per thread", async () => {
-    const agentRunsCol = await col<any>("agentRuns");
-    // Insert 510 runs for the same thread
-    for (let i = 0; i < 510; i++) {
-      await agentRunsCol.put(`run-${i}`, {
-        agent_id: "agent-1",
-        thread_id: "thread-1",
-        kind: "chat",
-        status: "completed",
-        created_at: i, // ascending so higher = newer
-        lease_expires_at: Date.now() + 60000,
-      });
-    }
-    const beforeCount = (await agentRunsCol.scan({})).length;
-    expect(beforeCount).toBe(510);
-
-    await reconcileOnBoot("test-boot");
-
-    const afterCount = (await agentRunsCol.scan({})).length;
-    expect(afterCount).toBe(500);
-
-    // Verify we kept the newest (highest created_at)
-    const remaining = await agentRunsCol.scan({});
-    const ids = remaining.map((e: any) => parseInt(e.id.split("-")[1]));
-    expect(Math.min(...ids)).toBe(10); // first 10 pruned, 10..509 kept
-  });
-
-  it("caps jobs to 500 per run_id", async () => {
-    const jobsCol = await col<any>("jobQueue");
-    for (let i = 0; i < 520; i++) {
-      await jobsCol.put(`job-${i}`, {
-        lane: "default",
-        type: "chat_turn",
-        status: "completed",
-        run_id: "run-1",
-        attempts: 1,
-        max_attempts: 3,
-        lease_expires_at: null,
-        created_at: i,
-        payload_json: "{}",
-        priority: 0,
-        not_before: 0,
-        boot_id: null,
-        result_json: null,
-        error: null,
-        started_at: null,
-        finished_at: null,
-      });
-    }
-    const beforeCount = (await jobsCol.scan({})).length;
-    expect(beforeCount).toBe(520);
-
-    await reconcileOnBoot("test-boot");
-
-    const afterCount = (await jobsCol.scan({})).length;
-    expect(afterCount).toBe(500);
-  });
-
-  it("does not prune when under the cap", async () => {
-    const agentRunsCol = await col<any>("agentRuns");
-    for (let i = 0; i < 100; i++) {
-      await agentRunsCol.put(`run-${i}`, {
-        agent_id: "agent-1",
-        thread_id: "thread-1",
-        kind: "chat",
-        status: "completed",
-        created_at: i,
-        lease_expires_at: Date.now() + 60000,
-      });
-    }
-
-    await reconcileOnBoot("test-boot");
-
-    const afterCount = (await agentRunsCol.scan({})).length;
-    expect(afterCount).toBe(100);
-  });
-});