@johpaz/hive-sdk 0.1.3 → 0.1.5

package/test/context-compiler.test.ts

@@ -0,0 +1,269 @@
+/**
+ * context-compiler tests: G9 causal context window (buildAgentContext).
+ *
+ * Exercises the real compileContext() path with a real (in-memory) HiveDB —
+ * only the pieces that would otherwise need network/process I/O
+ * (MCP manager, native tool executors) are left at their defaults since
+ * createAllTools() works standalone in-process.
+ */
+
+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, toIndexable } from "../packages/core/src/storage/hive";
+import { addMessage, saveSummary } from "../packages/core/src/agent/conversation-store";
+import { compileContext } from "../packages/core/src/agent/context-compiler";
+import type { AgentDoc, ModelDoc, ProviderDoc, UserDoc } from "../packages/core/src/storage/collections";
+
+async function seedAgentWithSmallContextWindow() {
+  const usersCol = await col<UserDoc>("users");
+  await usersCol.put("test-user", {
+    id: "test-user",
+    name: "Test User",
+    language: "es",
+    timezone: null,
+    occupation: null,
+    notes: null,
+    master_key_hash: null,
+    email: null,
+    password_hash: null,
+    preferred_cron_channel: "webchat",
+    created_at: Date.now(),
+  });
+
+  const agentsCol = await col<AgentDoc>("agents");
+  await agentsCol.put("test-agent", {
+    id: "test-agent",
+    user_id: "test-user",
+    name: "Test Agent",
+    description: null,
+    system_prompt: "Eres un agente de prueba.",
+    tone: null,
+    role: "coordinator",
+    status: "idle",
+    enabled: true,
+    provider_id: toIndexable("hiveagents"),
+    model_id: toIndexable("test-model"),
+    tools_json: null,
+    skills_json: null,
+    parent_id: toIndexable(null),
+    max_iterations: 10,
+    workspace: null,
+    lastTraceAt: null,
+    created_at: Date.now(),
+    updated_at: Date.now(),
+  });
+
+  const providersCol = await col<ProviderDoc>("providers");
+  await providersCol.put("hiveagents", {
+    id: "hiveagents",
+    name: "HiveAgents",
+    enabled: true,
+    active: true,
+    base_url: "https://fake.api.com/v1",
+    category: "llm",
+    num_ctx: null,
+    num_gpu: 0,
+    created_at: Date.now(),
+  });
+
+  // Small context window so a handful of messages is enough to cross
+  // compactThreshold (window * 0.8) and force the summary/compaction path.
+  const modelsCol = await col<ModelDoc>("models");
+  await modelsCol.put("test-model", {
+    id: "test-model",
+    provider_id: "hiveagents",
+    name: "Test Model",
+    model_type: "llm",
+    active: true,
+    enabled: true,
+    context_window: 1000,
+    capabilities: null,
+  });
+}
+
+// KEEP_LAST_N_MESSAGES in context-compiler.ts is 30 — insert enough messages
+// that the recent-messages window is a strict suffix starting AFTER the
+// summary's last_message_id. That's what makes a summary "apply": the window
+// no longer reaches back far enough to cover what the summary already does.
+async function forceCompaction(threadId: string) {
+  for (let i = 0; i < 35; i++) {
+    await addMessage(threadId, i % 2 === 0 ? "user" : "assistant", `msg-${i}`);
+  }
+  await saveSummary(threadId, "Resumen de la conversación previa.", 5, 5);
+}
+
+beforeEach(async () => {
+  closeHiveDb();
+  resetBootId();
+  await ensureHiveDb();
+  await seedAgentWithSmallContextWindow();
+});
+
+afterEach(() => {
+  closeHiveDb();
+  delete process.env.HIVE_CAUSAL_LOG;
+});
+
+describe("context-compiler: G9 causal context window", () => {
+  test("injects a # CAUSAL CONTEXT section once compaction fires and a causal stream has decisions", async () => {
+    process.env.HIVE_CAUSAL_LOG = "true";
+    const db = await getHiveDb();
+
+    const streamId = "ctx-stream-1";
+    const intentSeq = await db.append({
+      agentId: "test-agent",
+      streamId,
+      kind: "IntentLogged",
+      payload: JSON.stringify({ actor: "test-agent", intent: "deploy the checkout service" }),
+    });
+    await db.append({
+      agentId: "test-agent",
+      streamId,
+      kind: "StateTransition",
+      payload: JSON.stringify({ description: "Calling deploy_service on checkout" }),
+      causation: intentSeq,
+    });
+
+    await forceCompaction("thread-ctx-1");
+
+    const ctx = await compileContext({
+      agentId: "test-agent",
+      threadId: "thread-ctx-1",
+      userMessage: "Seguí con el deploy",
+      causalStreamId: streamId,
+    });
+
+    expect(ctx.systemPrompt).toContain("# CAUSAL CONTEXT");
+    expect(ctx.systemPrompt).toContain("Calling deploy_service on checkout");
+  });
+
+  test("does not inject a causal context section when causalLog is disabled", async () => {
+    process.env.HIVE_CAUSAL_LOG = "false";
+    const db = await getHiveDb();
+
+    const streamId = "ctx-stream-2";
+    const intentSeq = await db.append({
+      agentId: "test-agent",
+      streamId,
+      kind: "IntentLogged",
+      payload: JSON.stringify({ actor: "test-agent", intent: "deploy the checkout service" }),
+    });
+    await db.append({
+      agentId: "test-agent",
+      streamId,
+      kind: "StateTransition",
+      payload: JSON.stringify({ description: "Calling deploy_service on checkout" }),
+      causation: intentSeq,
+    });
+
+    await forceCompaction("thread-ctx-2");
+
+    const ctx = await compileContext({
+      agentId: "test-agent",
+      threadId: "thread-ctx-2",
+      userMessage: "Seguí con el deploy",
+      causalStreamId: streamId,
+    });
+
+    expect(ctx.systemPrompt).not.toContain("# CAUSAL CONTEXT");
+  });
+
+  test("does not inject a causal context section when compaction hasn't fired", async () => {
+    process.env.HIVE_CAUSAL_LOG = "true";
+    const db = await getHiveDb();
+
+    const streamId = "ctx-stream-3";
+    const intentSeq = await db.append({
+      agentId: "test-agent",
+      streamId,
+      kind: "IntentLogged",
+      payload: JSON.stringify({ actor: "test-agent", intent: "deploy the checkout service" }),
+    });
+    await db.append({
+      agentId: "test-agent",
+      streamId,
+      kind: "StateTransition",
+      payload: JSON.stringify({ description: "Calling deploy_service on checkout" }),
+      causation: intentSeq,
+    });
+
+    // No forceCompaction() call — conversation is short, no summary exists.
+
+    const ctx = await compileContext({
+      agentId: "test-agent",
+      threadId: "thread-ctx-3",
+      userMessage: "Hola",
+      causalStreamId: streamId,
+    });
+
+    expect(ctx.systemPrompt).not.toContain("# CAUSAL CONTEXT");
+  });
+});
+
+describe("context-compiler: conversation summary + internal events", () => {
+  test("folds the summary into systemPrompt as # RESUMEN DE LA CONVERSACIÓN when it applies", async () => {
+    await forceCompaction("thread-summary-1");
+
+    const ctx = await compileContext({
+      agentId: "test-agent",
+      threadId: "thread-summary-1",
+      userMessage: "Continuemos",
+    });
+
+    expect(ctx.systemPrompt).toContain("# RESUMEN DE LA CONVERSACIÓN");
+    expect(ctx.systemPrompt).toContain("Resumen de la conversación previa.");
+    expect(ctx.conversationSummarySection).not.toBe("");
+  });
+
+  test("does not include a summary section when none applies", async () => {
+    await addMessage("thread-summary-2", "user", "Hola");
+
+    const ctx = await compileContext({
+      agentId: "test-agent",
+      threadId: "thread-summary-2",
+      userMessage: "Hola de nuevo",
+    });
+
+    expect(ctx.systemPrompt).not.toContain("# RESUMEN DE LA CONVERSACIÓN");
+    expect(ctx.conversationSummarySection).toBe("");
+  });
+
+  test("never emits a second role:system message in ctx.messages, even when a summary applies", async () => {
+    await forceCompaction("thread-summary-3");
+
+    const ctx = await compileContext({
+      agentId: "test-agent",
+      threadId: "thread-summary-3",
+      userMessage: "Continuemos",
+    });
+
+    expect(ctx.messages.every((m) => m.role !== "system")).toBe(true);
+  });
+
+  test("an internal event keeps its chronological position and role:user in ctx.messages", async () => {
+    const threadId = "thread-internal-1";
+    await addMessage(threadId, "user", "Delegá esto a un worker");
+    await addMessage(threadId, "assistant", "Listo, delegado.");
+    await addMessage(threadId, "user", "El agente completó la tarea X.", { source: "task_complete" });
+    await addMessage(threadId, "assistant", "El worker terminó la tarea X exitosamente.");
+
+    const ctx = await compileContext({
+      agentId: "test-agent",
+      threadId,
+      userMessage: "¿Cómo va todo?",
+    });
+
+    expect(ctx.messages.every((m) => m.role !== "system")).toBe(true);
+
+    const idx = ctx.messages.findIndex(
+      (m) => typeof m.content === "string" && m.content.includes("hive:internal_event")
+    );
+    expect(idx).toBeGreaterThan(0);
+    expect(idx).toBeLessThan(ctx.messages.length - 1);
+    expect(ctx.messages[idx].role).toBe("user");
+  });
+});

package/test/curator.test.ts

@@ -0,0 +1,130 @@
+/**
+ * Curator tests: baseline regression coverage for the existing
+ * reflection → playbook pipeline (none existed before), plus the new
+ * category mapping for G9 evaluateHarness() insight types
+ * (root_cause/learning_proposal — see reflector.ts's analyzeCausalThreads).
+ */
+
+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 { resetBootId } from "../packages/core/src/storage/boot-id";
+import { col, nextId } from "../packages/core/src/storage/hive";
+import type { ReflectionDoc, PlaybookDoc } from "../packages/core/src/storage/collections";
+import { runCurator } from "../packages/core/src/agent/curator";
+
+async function seedReflection(overrides: Partial<ReflectionDoc>) {
+  const reflectionsCol = await col<ReflectionDoc>("reflections");
+  const id = await nextId("reflections");
+  await reflectionsCol.put(id, {
+    id,
+    trace_ids: "[]",
+    insight_type: "failure_pattern",
+    description: "Tool 'flaky_tool' failed 5 times recently.",
+    affected_tools: null,
+    affected_agents: null,
+    confidence: 0.5,
+    created_at: Date.now(),
+    ...overrides,
+  });
+  return id;
+}
+
+beforeEach(async () => {
+  closeHiveDb();
+  resetBootId();
+  await ensureHiveDb();
+});
+
+afterEach(() => {
+  closeHiveDb();
+});
+
+describe("curator: baseline reflection → playbook pipeline", () => {
+  test("a new reflection creates a new active playbook rule", async () => {
+    await seedReflection({ description: "Tool 'flaky_tool' failed 5 times recently." });
+
+    await runCurator();
+
+    const playbookCol = await col<PlaybookDoc>("playbook");
+    const all = await playbookCol.scan({});
+    const rule = all.find((e) => e.doc.rule === "Tool 'flaky_tool' failed 5 times recently.");
+    expect(rule).toBeDefined();
+    expect(rule!.doc.category).toBe("error_avoidance");
+    expect(rule!.doc.helpful_count).toBe(1);
+    expect(rule!.doc.harmful_count).toBe(0);
+    expect(rule!.doc.active).toBe(true);
+  });
+
+  test("a reflection matching an existing rule's prefix reinforces it instead of duplicating", async () => {
+    const description = "Tool 'flaky_tool' failed 5 times recently. Consider verifying its configuration.";
+    await seedReflection({ description });
+    await runCurator();
+
+    // Second, near-identical reflection (same first-60-chars prefix)
+    await seedReflection({ description: description + " Extra detail." });
+    await runCurator();
+
+    const playbookCol = await col<PlaybookDoc>("playbook");
+    const all = await playbookCol.scan({});
+    const matching = all.filter((e) => e.doc.rule.startsWith(description.substring(0, 60)));
+    expect(matching.length).toBe(1);
+    expect(matching[0].doc.helpful_count).toBe(2);
+  });
+
+  test("a rule with harmful_count >= 3 and > helpful_count is deactivated on the next curator run", async () => {
+    const playbookCol = await col<PlaybookDoc>("playbook");
+    const now = Date.now();
+    await playbookCol.put("bad-rule", {
+      id: "bad-rule",
+      rule: "This rule turned out to be harmful.",
+      category: "optimization",
+      applicable_to: null,
+      helpful_count: 1,
+      harmful_count: 3,
+      active: true,
+      source_reflection_id: "NO_PARENT",
+      created_at: now,
+      updated_at: now,
+    }, { expectedVersion: 0 });
+
+    await runCurator();
+
+    const entry = await playbookCol.get("bad-rule");
+    expect(entry!.doc.active).toBe(false);
+  });
+});
+
+describe("curator: G9 evaluateHarness() insight category mapping", () => {
+  test("root_cause insights map to the error_avoidance category", async () => {
+    await seedReflection({
+      insight_type: "root_cause",
+      description: "Root cause in stream s1: called deploy_prod without running tests first.",
+    });
+
+    await runCurator();
+
+    const playbookCol = await col<PlaybookDoc>("playbook");
+    const all = await playbookCol.scan({});
+    const rule = all.find((e) => e.doc.rule.startsWith("Root cause in stream s1"));
+    expect(rule).toBeDefined();
+    expect(rule!.doc.category).toBe("error_avoidance");
+  });
+
+  test("learning_proposal insights map to the response_quality category", async () => {
+    await seedReflection({
+      insight_type: "learning_proposal",
+      description: "Add pre-checks before calling tool 'flaky_tool' to avoid repeated errors",
+    });
+
+    await runCurator();
+
+    const playbookCol = await col<PlaybookDoc>("playbook");
+    const all = await playbookCol.scan({});
+    const rule = all.find((e) => e.doc.rule.startsWith("Add pre-checks before calling tool"));
+    expect(rule).toBeDefined();
+    expect(rule!.doc.category).toBe("response_quality");
+  });
+});

package/test/durable-queue.test.ts

@@ -0,0 +1,114 @@
+/**
+ * Tests: DurableLaneQueue — dispatch, boot re-dispatch, forced reclaim.
+ *
+ * 1. enqueue → dispatch → executor runs → job completed
+ * 2. start() dispatches jobs left pending by a previous boot
+ * 3. reconcileOnBoot reclaims "running" jobs immediately (single-process:
+ *    any running row at boot belongs to a dead process, lease ignored)
+ * 4. reclaimOrInterrupt force interrupts when attempts are exhausted
+ */
+
+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 { resetBootId, getBootId } from "../packages/core/src/storage/boot-id";
+import { DurableLaneQueue, registerExecutor } from "../packages/core/src/gateway/durable-queue";
+import { createJob, claimJob, getJob, reclaimOrInterrupt } from "../packages/core/src/gateway/job-store";
+import { reconcileOnBoot } from "../packages/core/src/storage/reconcile";
+
+let queue: DurableLaneQueue | null = null;
+
+beforeEach(async () => {
+  closeHiveDb();
+  resetBootId();
+  await ensureHiveDb();
+});
+
+afterEach(() => {
+  queue?.stop();
+  queue = null;
+  closeHiveDb();
+});
+
+async function waitFor(predicate: () => Promise<boolean>, timeoutMs = 3000): Promise<void> {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    if (await predicate()) return;
+    await new Promise((r) => setTimeout(r, 25));
+  }
+  throw new Error("waitFor timed out");
+}
+
+describe("durable-queue: dispatch + reclaim", () => {
+  test("enqueue dispatches the job and persists the executor result", async () => {
+    const executed: string[] = [];
+    registerExecutor("worker_task", async (job) => {
+      executed.push(job.id);
+      return { ok: true, result: "done!" };
+    });
+
+    queue = new DurableLaneQueue({ maxGlobalConcurrency: 2 });
+    const job = await queue.enqueue({
+      lane: "task:test-1",
+      type: "worker_task",
+      run_id: "run-x",
+      payload: { hello: "world" },
+    });
+
+    await waitFor(async () => (await getJob(job.id))?.status === "completed");
+
+    const finished = await getJob(job.id);
+    expect(executed).toContain(job.id);
+    expect(finished!.status).toBe("completed");
+    expect(JSON.parse(finished!.result_json!)).toBe("done!");
+    expect(finished!.boot_id).toBeNull();
+  });
+
+  test("start() re-dispatches jobs left pending by a previous boot", async () => {
+    const executed: string[] = [];
+    registerExecutor("worker_task", async (job) => {
+      executed.push(job.id);
+      return { ok: true, result: null };
+    });
+
+    // Jobs created directly (as if the process died right after enqueue)
+    const j1 = await createJob({ lane: "task:a", type: "worker_task", payload: {}, run_id: "r1" });
+    const j2 = await createJob({ lane: "task:b", type: "worker_task", payload: {}, run_id: "r2" });
+
+    queue = new DurableLaneQueue({ maxGlobalConcurrency: 2 });
+    queue.start();
+
+    await waitFor(async () =>
+      (await getJob(j1.id))?.status === "completed" && (await getJob(j2.id))?.status === "completed"
+    );
+    expect(executed.sort()).toEqual([j1.id, j2.id].sort());
+  });
+
+  test("reconcileOnBoot reclaims a running job immediately, ignoring its lease", async () => {
+    const job = await createJob({ lane: "task:c", type: "worker_task", payload: {}, run_id: "r3" });
+    const claimed = await claimJob(job.id, "dead-boot");
+    expect(claimed!.status).toBe("running");
+    // Lease is still fresh (30 min) — at boot it must be reclaimed anyway
+    expect(claimed!.lease_expires_at! > Date.now()).toBe(true);
+
+    await reconcileOnBoot(getBootId());
+
+    const after = await getJob(job.id);
+    expect(after!.status).toBe("pending");
+    expect(after!.boot_id).toBeNull();
+    expect(after!.attempts).toBe(1);
+  });
+
+  test("forced reclaim interrupts the job when attempts are exhausted", async () => {
+    const job = await createJob({ lane: "task:d", type: "worker_task", payload: {}, run_id: "r4", max_attempts: 2 });
+    await claimJob(job.id, "boot-1");            // attempts = 1
+    await reclaimOrInterrupt(job.id, { force: true }); // back to pending
+    await claimJob(job.id, "boot-2");            // attempts = 2
+    const final = await reclaimOrInterrupt(job.id, { force: true });
+
+    expect(final!.status).toBe("interrupted");
+    expect(final!.error).toContain("Max attempts");
+  });
+});

package/test/harness-barrel.test.ts

@@ -0,0 +1,64 @@
+/**
+ * `harness/` pasó de tener implementación propia a ser un barrel.
+ *
+ * Hasta 0.1.5 el módulo traía sus propias copias de `db-helpers`, `boot-id`,
+ * `reconcile`, `collections`, `run-store`, `run-epoch` y `proof-packet`, en
+ * paralelo con las de `storage/` y `agent/`. Dos almacenes de jobs sobre las
+ * mismas colecciones de HiveDB son una sola cosa con dos estados posibles.
+ *
+ * Lo que este test protege no es el comportamiento (eso lo cubren
+ * job-store/durable-queue/run-store.test.ts) sino el contrato del subpath
+ * `@johpaz/hive-sdk/harness`: que siga exportando los mismos nombres y que
+ * apunten a la implementación única.
+ */
+
+process.env.HIVE_DB_PATH = ":memory:";
+
+import { describe, test, expect } from "bun:test";
+import * as harness from "../packages/core/src/harness/index.ts";
+import { createJob } from "../packages/core/src/gateway/job-store.ts";
+import { createRun } from "../packages/core/src/agent/run-store.ts";
+import { col } from "../packages/core/src/storage/hive.ts";
+
+describe("subpath @johpaz/hive-sdk/harness", () => {
+  test("sigue exportando la superficie que tenía", () => {
+    for (const name of [
+      "createJob",
+      "getJob",
+      "registerExecutor",
+      "getDurableQueue",
+      "initDurableQueue",
+      "DurableLaneQueue",
+      "createRun",
+      "checkpoint",
+      "completeRun",
+      "failRun",
+      "interruptRun",
+      "reclaimRun",
+      "getRun",
+      "buildRunEpoch",
+      "buildProofPacket",
+      "verifyGoal",
+      "getBootId",
+      "resetBootId",
+      "reconcileOnBoot",
+      "ensureHarnessIndexes",
+      "col",
+      "nextId",
+      "updateDoc",
+      "findByAny",
+      "toIndexable",
+      "fromIndexable",
+      "NO_PARENT",
+    ]) {
+      expect(harness[name as keyof typeof harness], `falta el export ${name}`).toBeDefined();
+    }
+  });
+
+  test("re-exporta la misma función, no una copia", () => {
+    // Si esto falla es que harness/ volvió a tener implementación propia.
+    expect(harness.createJob).toBe(createJob);
+    expect(harness.createRun).toBe(createRun);
+    expect(harness.col).toBe(col);
+  });
+});