@johpaz/hive-sdk 0.1.6 → 0.2.0

package/test/secrets-durability.test.ts

@@ -1,119 +0,0 @@
-/**
- * Secrets must survive a server restart.
- *
- * Regression test for provider API keys (and channel tokens / MCP headers)
- * vanishing on every restart in production: they were written to the OS
- * keychain only, which throws on headless Linux/Docker, leaving the value in
- * a per-process in-memory map that dies with the process.
- *
- * The durability half runs in real subprocesses against a real on-disk
- * HIVE_HOME — a restart is the whole point, so it cannot be faked in-process.
- */
-
-import { describe, test, expect, afterAll } from "bun:test";
-import { mkdtempSync, rmSync, statSync } from "node:fs";
-import { tmpdir } from "node:os";
-import * as path from "node:path";
-
-const CORE = path.join(import.meta.dir, "..", "packages", "core", "src");
-const hiveHome = mkdtempSync(path.join(tmpdir(), "hive-secrets-"));
-
-// Set before anything imports storage/*: the in-process half of this file
-// mints a master key, and it must land in the temp dir, never in the real
-// ~/.hive of whoever runs the suite.
-process.env.HIVE_HOME = hiveHome;
-process.env.HIVE_DB_PATH = ":memory:";
-
-afterAll(() => {
-  rmSync(hiveHome, { recursive: true, force: true });
-});
-
-/** Run `body` in a fresh process with no OS keychain available. */
-async function inRestartedProcess(body: string): Promise<string> {
-  const script = `
-    process.env.HIVE_HOME = ${JSON.stringify(hiveHome)};
-    // Headless Linux / Docker: Bun.secrets has no libsecret to talk to.
-    (Bun as any).secrets = {
-      get: async () => { throw new Error("keychain unavailable") },
-      set: async () => { throw new Error("keychain unavailable") },
-      delete: async () => { throw new Error("keychain unavailable") },
-    };
-    const crypto = await import(${JSON.stringify(path.join(CORE, "storage", "crypto.ts"))});
-    const out = await (async () => { ${body} })();
-    console.log("__RESULT__" + JSON.stringify(out));
-    (await import(${JSON.stringify(path.join(CORE, "storage", "hivedb.ts"))})).closeHiveDb();
-  `;
-  const proc = Bun.spawn(["bun", "-e", script], { stdout: "pipe", stderr: "pipe" });
-  const stdout = await new Response(proc.stdout).text();
-  await proc.exited;
-  const line = stdout.split("\n").find((l) => l.startsWith("__RESULT__"));
-  if (!line) throw new Error(`subprocess produced no result:\n${stdout}\n${await new Response(proc.stderr).text()}`);
-  return line.slice("__RESULT__".length);
-}
-
-describe("secret durability without an OS keychain", () => {
-  test("provider API keys and channel tokens survive a restart", async () => {
-    const written = JSON.parse(
-      await inRestartedProcess(`
-        return {
-          provider: await crypto.storeProviderApiKey("openai", "sk-durable-1234567890"),
-          channel: await crypto.storeChannelConfig("telegram", { botToken: "123:ABC" }),
-        };
-      `)
-    );
-    // Reported as durable at write time — callers can trust the return value.
-    expect(written).toEqual({ provider: true, channel: true });
-
-    const read = JSON.parse(
-      await inRestartedProcess(`
-        return {
-          provider: await crypto.loadProviderApiKey("openai"),
-          channel: await crypto.loadChannelConfig("telegram"),
-        };
-      `)
-    );
-    expect(read.provider).toBe("sk-durable-1234567890");
-    expect(read.channel).toEqual({ botToken: "123:ABC" });
-  }, 30_000);
-
-  test("the master key is generated once, readable only by its owner", async () => {
-    const keyPath = path.join(hiveHome, ".master.key");
-    const mode = statSync(keyPath).mode & 0o777;
-    expect(mode).toBe(0o600);
-
-    const before = await Bun.file(keyPath).text();
-    await inRestartedProcess(`return await crypto.loadProviderApiKey("openai")`);
-    // A second boot must reuse the key — regenerating it would orphan every
-    // secret already encrypted with the old one.
-    expect(await Bun.file(keyPath).text()).toBe(before);
-  }, 30_000);
-
-  test("deleting a secret removes it from the durable store too", async () => {
-    await inRestartedProcess(`return await crypto.deleteProviderSecrets("openai")`);
-    const read = await inRestartedProcess(`return await crypto.loadProviderApiKey("openai")`);
-    expect(JSON.parse(read)).toBe("");
-  }, 30_000);
-});
-
-describe("keychain compatibility", () => {
-  test("a secret that only exists in the OS keychain is still readable", async () => {
-    const keychain = new Map<string, string>([["provider:legacy:api_key", "sk-from-keychain"]]);
-    const original = (Bun as any).secrets;
-    (Bun as any).secrets = {
-      get: async ({ name }: { name: string }) => keychain.get(name) ?? null,
-      set: async ({ name, value }: { name: string; value: string }) => void keychain.set(name, value),
-      delete: async ({ name }: { name: string }) => void keychain.delete(name),
-    };
-    try {
-      const { loadProviderApiKey, storeProviderApiKey } = await import("../packages/core/src/storage/crypto");
-      expect(await loadProviderApiKey("legacy")).toBe("sk-from-keychain");
-
-      // New writes are mirrored to the keychain as well, so a downgrade or a
-      // desktop install keeps working the way it did before.
-      await storeProviderApiKey("mirrored", "sk-mirrored");
-      expect(keychain.get("provider:mirrored:api_key")).toBe("sk-mirrored");
-    } finally {
-      (Bun as any).secrets = original;
-    }
-  });
-});

package/test/seed-model-reseed.test.ts

@@ -1,155 +0,0 @@
-/**
- * Semántica del re-seed de modelos: wipe & recreate.
- *
- * Actualizar el catálogo debe ser editar SEED_DATA.models y arrancar. Eso exige
- * que las filas de catálogo se borren enteras (para que ningún campo viejo
- * sobreviva a una entrada corregida) sin llevarse por delante ni la elección del
- * usuario, ni los modelos descubiertos en runtime, ni los providers/claves.
- */
-
-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 { ModelDoc, ProviderDoc } from "../packages/core/src/storage/collections";
-import { seedAllData, SEED_DATA } from "../packages/core/src/storage/seed";
-import { catalogModelKey } from "../packages/core/src/storage/model-id";
-
-beforeEach(async () => {
-  closeHiveDb();
-  await ensureHiveDb();
-});
-
-afterEach(() => {
-  closeHiveDb();
-});
-
-const A_SEEDED_MODEL = () => {
-  const m = SEED_DATA.models.find((x) => x.modelType === "llm" && x.providerId === "anthropic")!;
-  return catalogModelKey(m.providerId, m.id);
-};
-
-describe("re-seed de modelos", () => {
-  test("preserva enabled/active de los ids que sobreviven", async () => {
-    const modelsCol = await col<ModelDoc>("models");
-    const id = A_SEEDED_MODEL();
-
-    const before = await modelsCol.get(id);
-    expect(before).toBeTruthy();
-    await modelsCol.put(id, { ...before!.doc, active: true, enabled: true }, { expectedVersion: before!.version });
-
-    await seedAllData();
-
-    const after = await modelsCol.get(id);
-    expect(after!.doc.active).toBe(true);
-    expect(after!.doc.enabled).toBe(true);
-  });
-
-  test("borra las filas de catálogo que salieron del seed", async () => {
-    const modelsCol = await col<ModelDoc>("models");
-    // Una fila de catálogo que ya no está en SEED_DATA (modelo retirado, como
-    // los 8 modelos NVIDIA que devolvían 410).
-    await modelsCol.put("provider-x/modelo-retirado", {
-      id: "provider-x/modelo-retirado", provider_id: "nvidia", name: "Retirado",
-      model_type: "llm", context_window: 1000, capabilities: null,
-      enabled: true, active: true, source: "catalog",
-      input_per_1m: 1, output_per_1m: 1,
-    });
-
-    await seedAllData();
-
-    expect(await modelsCol.get("provider-x/modelo-retirado")).toBeFalsy();
-  });
-
-  test("conserva los modelos descubiertos en runtime", async () => {
-    const modelsCol = await col<ModelDoc>("models");
-    await modelsCol.put("llama3.3:8b", {
-      id: "llama3.3:8b", provider_id: "ollama", name: "llama3.3:8b",
-      model_type: "llm", context_window: 0, capabilities: null,
-      enabled: true, active: true, source: "discovered",
-      input_per_1m: 0, output_per_1m: 0,
-    });
-
-    await seedAllData();
-
-    const survivor = await modelsCol.get("llama3.3:8b");
-    expect(survivor).toBeTruthy();
-    expect(survivor!.doc.active).toBe(true);
-  });
-
-  test("recrea los campos de catálogo desde cero", async () => {
-    const modelsCol = await col<ModelDoc>("models");
-    const id = A_SEEDED_MODEL();
-    const original = (await modelsCol.get(id))!;
-
-    // Un valor corrupto/desactualizado no debe sobrevivir al re-seed.
-    await modelsCol.put(id, { ...original.doc, context_window: 42, input_per_1m: 999 }, { expectedVersion: original.version });
-
-    await seedAllData();
-
-    const after = (await modelsCol.get(id))!.doc;
-    expect(after.context_window).toBe(original.doc.context_window);
-    expect(after.input_per_1m).toBe(original.doc.input_per_1m ?? null);
-  });
-
-  test("cada modelo llm queda con su precio en la BD", async () => {
-    const modelsCol = await col<ModelDoc>("models");
-    const rows = (await modelsCol.scan({})).filter((r) => r.doc.model_type === "llm" && r.doc.source === "catalog");
-
-    expect(rows.length).toBeGreaterThan(0);
-    const sinPrecio = rows
-      .filter((r) => typeof r.doc.input_per_1m !== "number" || typeof r.doc.output_per_1m !== "number")
-      .map((r) => r.id);
-    expect(sinPrecio).toEqual([]);
-  });
-
-  test("los ids de revendedor quedan prefijados y no colisionan", async () => {
-    const modelsCol = await col<ModelDoc>("models");
-
-    // z-ai/glm-5.2 se sirve desde NVIDIA y desde OpenRouter: antes una fila
-    // pisaba a la otra porque la colección se indexaba sólo por model id.
-    const nvidia = await modelsCol.get("nvidia/z-ai/glm-5.2");
-    const openrouter = await modelsCol.get("openrouter/z-ai/glm-5.2");
-
-    expect(nvidia?.doc.provider_id).toBe("nvidia");
-    expect(openrouter?.doc.provider_id).toBe("openrouter");
-    // Endpoint gratuito de NVIDIA vs. OpenRouter de pago — el costo ya no se confunde.
-    expect(nvidia!.doc.input_per_1m).toBe(0);
-    expect(openrouter!.doc.input_per_1m).toBeGreaterThan(0);
-  });
-});
-
-describe("re-seed de providers", () => {
-  test("es sólo aditivo: no borra ni reescribe los existentes", async () => {
-    const providersCol = await col<ProviderDoc>("providers");
-
-    // El usuario activó un provider y le puso un base_url propio.
-    const anthropic = (await providersCol.get("anthropic"))!;
-    await providersCol.put("anthropic", { ...anthropic.doc, active: true, enabled: true, base_url: "https://proxy.interno" }, { expectedVersion: anthropic.version });
-
-    // Y tiene un provider que ya no está en el catálogo.
-    await providersCol.put("provider-propio", {
-      id: "provider-propio", name: "Propio", base_url: null, category: "llm",
-      num_ctx: null, num_gpu: -1, enabled: true, active: true, created_at: Date.now(),
-    });
-
-    await seedAllData();
-
-    const after = (await providersCol.get("anthropic"))!.doc;
-    expect(after.base_url).toBe("https://proxy.interno");
-    expect(after.active).toBe(true);
-    expect(await providersCol.get("provider-propio")).toBeTruthy();
-  });
-
-  test("crea los providers del catálogo que faltaban", async () => {
-    const providersCol = await col<ProviderDoc>("providers");
-    await providersCol.delete("z-ai");
-    expect(await providersCol.get("z-ai")).toBeFalsy();
-
-    await seedAllData();
-
-    expect(await providersCol.get("z-ai")).toBeTruthy();
-  });
-});

package/test/setup-agent-seed.test.ts

@@ -1,264 +0,0 @@
-/**
- * Tests for the setup/onboarding step that seeds every agent row with the
- * coordinator's provider/model. Uses HIVE_DB_PATH=":memory:" so no state
- * persists between runs.
- */
-
-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, fromIndexable, toIndexable } from "../packages/core/src/storage/hive";
-import type { AgentDoc, ModelDoc } from "../packages/core/src/storage/collections";
-import { seedAllData } from "../packages/core/src/storage/seed";
-import { saveAgentConfig, propagateCoordinatorModel } from "../packages/core/src/storage/onboarding";
-import { CATALOG_AGENT_IDS } from "../packages/core/src/agent/agent-catalog";
-
-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;
-}
-
-describe("catalog agents after boot", () => {
-  test("are seeded without a provider/model pair", async () => {
-    for (const id of CATALOG_AGENT_IDS) {
-      const doc = await agent(id);
-      expect(fromIndexable(doc.provider_id)).toBeNull();
-      expect(fromIndexable(doc.model_id)).toBeNull();
-    }
-  });
-});
-
-describe("saveAgentConfig", () => {
-  test("seeds every catalog agent with the coordinator's provider/model", async () => {
-    const agentId = await saveAgentConfig({
-      userId: "user-1",
-      agentName: "Bee",
-      tone: "friendly",
-      providerId: "gemini",
-      modelId: "gemini-3.6-flash",
-    });
-
-    const coordinator = await agent(agentId);
-    expect(coordinator.role).toBe("coordinator");
-    expect(fromIndexable(coordinator.provider_id)).toBe("gemini");
-
-    for (const id of CATALOG_AGENT_IDS) {
-      const doc = await agent(id);
-      expect(fromIndexable(doc.provider_id)).toBe("gemini");
-      expect(fromIndexable(doc.model_id)).toBe("gemini-3.6-flash");
-      expect(doc.user_id).toBe("user-1");
-      expect(doc.role).toBe("worker");
-      // The rest of the persona survives the rewrite untouched
-      expect(doc.enabled).toBe(true);
-      expect(doc.status).toBe("idle");
-      expect(doc.source).toBe("catalog");
-      expect(doc.tool_allowlist_json).toBeTruthy();
-      expect(doc.system_prompt.length).toBeGreaterThan(0);
-    }
-  });
-
-  test("leaves the workers untouched while the coordinator has no model yet", async () => {
-    await saveAgentConfig({
-      userId: "user-1",
-      agentName: "Bee",
-      tone: "friendly",
-      providerId: "",
-      modelId: "",
-    });
-
-    const doc = await agent(CATALOG_AGENT_IDS[0]);
-    expect(fromIndexable(doc.provider_id)).toBeNull();
-    expect(fromIndexable(doc.model_id)).toBeNull();
-  });
-
-  test("ignores a provider/model that is not in the catalog tables", async () => {
-    await saveAgentConfig({
-      userId: "user-1",
-      agentName: "Bee",
-      tone: "friendly",
-      providerId: "not-a-provider",
-      modelId: "not-a-model",
-    });
-
-    const doc = await agent(CATALOG_AGENT_IDS[0]);
-    expect(fromIndexable(doc.provider_id)).toBeNull();
-  });
-});
-
-describe("reseed on an already-configured install (boot, no setup)", () => {
-  async function configuredInstall(): Promise<string> {
-    return saveAgentConfig({
-      userId: "user-1",
-      agentName: "Bee",
-      tone: "friendly",
-      providerId: "gemini",
-      modelId: "gemini-3.6-flash",
-    });
-  }
-
-  test("keeps every agent enabled and configured across a reseed", async () => {
-    const coordinatorId = await configuredInstall();
-    const agentsCol = await col<AgentDoc>("agents");
-    // A worker the user pointed at a different model from the UI
-    const custom = { ...(await agent(CATALOG_AGENT_IDS[0])), id: "custom-worker" };
-    await agentsCol.put(custom.id, { ...custom, provider_id: toIndexable("openai"), model_id: toIndexable("gpt-5.6-luna") });
-    // A persona the user disabled
-    const off = await agent(CATALOG_AGENT_IDS[1]);
-    await agentsCol.put(off.id, { ...off, enabled: false }, { expectedVersion: (await agentsCol.get(off.id))!.version });
-
-    await seedAllData();
-
-    expect(fromIndexable((await agent(coordinatorId)).model_id)).toBe("gemini-3.6-flash");
-    for (const id of CATALOG_AGENT_IDS) {
-      const doc = await agent(id);
-      expect(fromIndexable(doc.provider_id)).toBe("gemini");
-      expect(fromIndexable(doc.model_id)).toBe("gemini-3.6-flash");
-    }
-    // Per-agent choices and toggles survive the reseed
-    expect(fromIndexable((await agent("custom-worker")).model_id)).toBe("gpt-5.6-luna");
-    expect((await agent(CATALOG_AGENT_IDS[1])).enabled).toBe(false);
-  });
-
-  test("migrates the legacy cron persona stored in the database", async () => {
-    await configuredInstall();
-    const agentsCol = await col<AgentDoc>("agents");
-    const cronId = "schedule_automation_agent";
-    const current = (await agentsCol.get(cronId))!;
-    await agentsCol.put(cronId, {
-      ...current.doc,
-      name: "Operador de agenda",
-      description: "Crea y administra recordatorios y automatizaciones temporales con zona horaria correcta.",
-      system_prompt: current.doc.system_prompt
-        .replace(
-          "Tu dominio son los jobs técnicos programados de Hive, su recurrencia, ventanas temporales y zonas horarias.",
-          "Tu dominio es recordatorios, cron recurrente, ventanas temporales y zonas horarias.",
-        )
-        .replace(
-          "Una automatización que Hive debe ejecutar después, su horario o recurrencia, timezone, canal y comportamiento esperado.",
-          "Acción temporal, horario expresado por el usuario, timezone, canal y comportamiento esperado.",
-        ),
-      enabled: false,
-      helpful_count: 7,
-    }, { expectedVersion: current.version });
-
-    await seedAllData();
-
-    const migrated = await agent(cronId);
-    expect(migrated.name).toBe("Operador de cron");
-    expect(migrated.description).toContain("jobs programados");
-    expect(migrated.system_prompt).toContain("jobs técnicos programados");
-    expect(migrated.system_prompt).not.toContain("Tu dominio es recordatorios");
-    expect(migrated.enabled).toBe(false);
-    expect(migrated.helpful_count).toBe(7);
-    expect(fromIndexable(migrated.model_id)).toBe("gemini-3.6-flash");
-  });
-
-  test("configures a persona added by an upgrade", async () => {
-    await configuredInstall();
-    const agentsCol = await col<AgentDoc>("agents");
-    // Simulates a new catalog row landing blank, the way createSeedCatalogAgents seeds it
-    const fresh = {
-      ...(await agent(CATALOG_AGENT_IDS[0])),
-      id: "new_persona",
-      user_id: "",
-      provider_id: toIndexable(null),
-      model_id: toIndexable(null),
-    };
-    await agentsCol.put(fresh.id, fresh);
-
-    await seedAllData();
-
-    const doc = await agent("new_persona");
-    expect(fromIndexable(doc.provider_id)).toBe("gemini");
-    expect(fromIndexable(doc.model_id)).toBe("gemini-3.6-flash");
-    expect(doc.user_id).toBe("user-1");
-    expect(doc.enabled).toBe(true);
-  });
-
-  test("keeps a model discovered from a provider, and the agents pointing at it", async () => {
-    const modelsCol = await col<ModelDoc>("models");
-    await modelsCol.put("llama3.2:latest", {
-      id: "llama3.2:latest", provider_id: "ollama", name: "llama3.2:latest", model_type: "llm",
-      context_window: 0, capabilities: null, enabled: true, active: true, source: "discovered",
-    });
-    const coordinatorId = await saveAgentConfig({
-      userId: "user-1",
-      agentName: "Bee",
-      tone: "friendly",
-      providerId: "ollama",
-      modelId: "llama3.2:latest",
-    });
-
-    await seedAllData();
-
-    expect(await modelsCol.get("llama3.2:latest")).toBeTruthy();
-    expect(fromIndexable((await agent(coordinatorId)).model_id)).toBe("llama3.2:latest");
-    expect(fromIndexable((await agent(CATALOG_AGENT_IDS[0])).model_id)).toBe("llama3.2:latest");
-  });
-
-  test("still unlinks agents from a catalog model that was dropped", async () => {
-    const modelsCol = await col<ModelDoc>("models");
-    await modelsCol.put("retired-model", {
-      id: "retired-model", provider_id: "gemini", name: "retired", model_type: "llm",
-      context_window: 0, capabilities: null, enabled: true, active: true, source: "catalog",
-    });
-    const agentsCol = await col<AgentDoc>("agents");
-    const orphan = { ...(await agent(CATALOG_AGENT_IDS[0])), id: "orphan-worker", model_id: toIndexable("retired-model") };
-    await agentsCol.put(orphan.id, orphan);
-
-    await seedAllData();
-
-    expect(await modelsCol.get("retired-model")).toBeUndefined();
-    // No coordinator configured here, so nothing refills it
-    expect(fromIndexable((await agent("orphan-worker")).model_id)).toBeNull();
-  });
-});
-
-describe("propagateCoordinatorModel", () => {
-  test("covers workers created outside the catalog and skips coordinators", async () => {
-    const agentsCol = await col<AgentDoc>("agents");
-    const now = Date.now();
-    const worker = { ...(await agent(CATALOG_AGENT_IDS[0])), id: "custom-worker", source: "user" as const };
-    await agentsCol.put(worker.id, worker);
-    const coordinatorId = await saveAgentConfig({
-      userId: "user-1",
-      agentName: "Bee",
-      tone: "friendly",
-      providerId: "gemini",
-      modelId: "gemini-3.6-flash",
-    });
-
-    const updated = await propagateCoordinatorModel("user-1", "openai", "gpt-5.6-luna");
-    expect(updated).toBe(CATALOG_AGENT_IDS.length + 1);
-    expect(fromIndexable((await agent("custom-worker")).provider_id)).toBe("openai");
-    // The coordinator keeps what saveAgentConfig persisted for it
-    expect(fromIndexable((await agent(coordinatorId)).model_id)).toBe("gemini-3.6-flash");
-    expect((await agent(CATALOG_AGENT_IDS[0])).updated_at).toBeGreaterThanOrEqual(now);
-
-    // Idempotent: a second run with the same pair rewrites nothing
-    expect(await propagateCoordinatorModel("user-1", "openai", "gpt-5.6-luna")).toBe(0);
-  });
-
-  test("keeps a user_id that is already set", async () => {
-    const agentsCol = await col<AgentDoc>("agents");
-    const owned = { ...(await agent(CATALOG_AGENT_IDS[0])), id: "owned-worker", user_id: "other-user" };
-    await agentsCol.put(owned.id, owned);
-
-    await propagateCoordinatorModel("user-1", "openai", "gpt-5.6-luna");
-
-    expect((await agent("owned-worker")).user_id).toBe("other-user");
-    expect((await agent("owned-worker")).provider_id).toBe(toIndexable("openai"));
-  });
-});

package/test/tool-inventory.test.ts

@@ -1,65 +0,0 @@
-/**
- * The tool inventory has three sources that must agree:
- *
- *  - `createAllTools()`      — the executors that actually exist
- *  - `CORE_TOOL_CATALOG`     — bilingual descriptions (drives BM25 ranking)
- *  - `SEED_DATA.tools`       — the DB rows (drive the tools UI)
- *
- * The search index is built as `CORE_TOOL_CATALOG ∪ seed rows`
- * (tool-selector.ts). Two failure modes follow, and both have shipped before:
- *
- *  - indexed without an executor → the agent discovers a tool and it blows up
- *  - executor without indexing   → working capability nobody can ever find
- *
- * Uses HIVE_DB_PATH=":memory:".
- */
-
-process.env.HIVE_DB_PATH = ":memory:";
-
-import { describe, test, expect } from "bun:test";
-import { createAllTools } from "../packages/core/src/tools/index";
-import { CORE_TOOL_CATALOG } from "../packages/core/src/agent/tool-selector";
-import { SEED_DATA } from "../packages/core/src/storage/seed";
-
-const executors = new Set(createAllTools({ tools: {} } as never).map((t) => t.name));
-const catalog = new Set(CORE_TOOL_CATALOG.map((t) => t.name));
-const seeded = new Set(SEED_DATA.tools.map((t) => t.id));
-const indexed = new Set([...catalog, ...seeded]);
-
-describe("tool inventory", () => {
-  test("nothing is indexed without a working executor", () => {
-    const ghosts = [...indexed].filter((name) => !executors.has(name)).sort();
-    expect(ghosts).toEqual([]);
-  });
-
-  test("every executor is reachable through search_knowledge", () => {
-    const invisible = [...executors].filter((name) => !indexed.has(name)).sort();
-    expect(invisible).toEqual([]);
-  });
-
-  test("every tool carries bilingual keywords for BM25 ranking", () => {
-    // A seed row alone gets indexed, but with only its own description; the
-    // catalog entry is what supplies the ES/EN synonyms that make it findable.
-    const withoutKeywords = [...executors].filter((name) => !catalog.has(name)).sort();
-    expect(withoutKeywords).toEqual([]);
-  });
-
-  test("seed rows are internally consistent", () => {
-    const ids = SEED_DATA.tools.map((t) => t.id);
-    expect(ids.length).toBe(new Set(ids).size); // no duplicates
-    expect(SEED_DATA.tools.filter((t) => t.id !== t.name)).toEqual([]);
-  });
-
-  test("the catalog has no duplicate entries", () => {
-    const names = CORE_TOOL_CATALOG.map((t) => t.name);
-    const dupes = names.filter((n, i) => names.indexOf(n) !== i).sort();
-    expect(dupes).toEqual([]);
-  });
-
-  test("the retired projects/DAG tools are gone for good", () => {
-    for (const name of ["project_create", "project_status", "task_create", "task_complete"]) {
-      expect(executors.has(name)).toBe(false);
-      expect(indexed.has(name)).toBe(false);
-    }
-  });
-});