@johpaz/hive-sdk 0.0.18 → 0.1.3

package/packages/core/src/harness/proof-packet.ts

@@ -0,0 +1,69 @@
+/**
+ * Proof packets — compressed evidence artifact for a completed run
+ * (harness-engineering "proof" practice): what was intended, what was
+ * checked, what evidence backs the verdict, and known limits. Written once
+ * per run so a reviewer doesn't have to replay the whole run to trust its
+ * outcome.
+ */
+
+import { col, nextId } from "./db-helpers";
+import type { ProofPacketDoc } from "./collections";
+import type { AcceptanceResult } from "./goal-verifier";
+import type { RunEpoch } from "./run-epoch";
+import { logger } from "../utils/logger";
+
+const log = logger.child("harness:proof-packet");
+
+const COLLECTION = "harness_proofPackets";
+
+export interface BuildProofPacketInput {
+  runId: string;
+  agentId: string;
+  intendedOutcome: string;
+  met: boolean;
+  /** Per-criterion verdicts when acceptance criteria were set; falls back to a single-entry summary otherwise. */
+  acceptanceResults?: AcceptanceResult[];
+  checksRun: string[];
+  evidence: string[];
+  knownLimits?: string | null;
+  epoch?: RunEpoch | null;
+}
+
+export async function buildProofPacket(input: BuildProofPacketInput): Promise<ProofPacketDoc> {
+  const id = await nextId(COLLECTION);
+  const acceptanceResults: AcceptanceResult[] =
+    input.acceptanceResults ?? [{ id: "goal", description: input.intendedOutcome, met: input.met, evidence: input.evidence.join("; ") || "n/a" }];
+
+  const doc: ProofPacketDoc = {
+    id,
+    run_id: input.runId,
+    agent_id: input.agentId,
+    intended_outcome: input.intendedOutcome,
+    acceptance_results_json: JSON.stringify(acceptanceResults),
+    checks_run_json: JSON.stringify(input.checksRun),
+    evidence_json: JSON.stringify(input.evidence),
+    known_limits: input.knownLimits ?? null,
+    epoch_json: input.epoch ? JSON.stringify(input.epoch) : null,
+    met: input.met,
+    created_at: Date.now(),
+  };
+
+  const c = await col<ProofPacketDoc>(COLLECTION);
+  await c.put(id, doc, { expectedVersion: 0 });
+  log.info(`[buildProofPacket] Packet ${id} written for run ${input.runId} (met=${input.met})`);
+  return doc;
+}
+
+export async function findProofPacketsByRun(runId: string): Promise<ProofPacketDoc[]> {
+  const c = await col<ProofPacketDoc>(COLLECTION);
+  const entries = await c.findBy("run_id", runId);
+  return entries.map((e) => e.doc);
+}
+
+export async function ensureProofPacketIndexes(): Promise<void> {
+  const c = await col<ProofPacketDoc>(COLLECTION);
+  await c.createIndex("run_id");
+  await c.createIndex("agent_id");
+}
+
+export { COLLECTION as PROOF_PACKETS_COLLECTION };

package/packages/core/src/harness/reconcile.ts

@@ -0,0 +1,149 @@
+/**
+ * reconcileOnBoot — repair harness rows left in inconsistent states by a
+ * previous crash/kill, plus a retention cap. Ported from `hive`'s
+ * storage/reconcile.ts, trimmed to only the generic harness collections
+ * (agentRuns/jobQueue) — `hive`'s version also repairs app-specific rows
+ * (taskRuns, meetingSessions, project tasks) that don't exist in the SDK.
+ *
+ * Call early in a host app's boot sequence, before `initDurableQueue`.
+ */
+
+import { col } from "./db-helpers";
+import type { HarnessRunDoc } from "./collections";
+import type { JobDoc } from "./collections";
+import { logger } from "../utils/logger";
+import { reclaimOrInterrupt, JOB_QUEUE_COLLECTION } from "./job-store";
+import { interruptRun, AGENT_RUNS_COLLECTION } from "./run-store";
+
+const log = logger.child("harness:reconcile");
+
+export interface ReconcileResult {
+  bootId: string;
+  runsInterrupted: number;
+  runsReEnqueueable: number;
+  jobsReclaimed: number;
+  jobsInterrupted: number;
+  runsPruned: number;
+  jobsPruned: number;
+}
+
+export interface ReconcileOptions {
+  /** Run kinds treated as "interactive" (interrupted outright rather than flagged for re-enqueue). Default: ["chat"]. */
+  interactiveKinds?: string[];
+  /** Retention cap per thread/run. Default: 500. */
+  retentionLimit?: number;
+  /** Called when an interactive run is interrupted, so the host can notify the user. */
+  onInteractiveInterrupted?: (run: HarnessRunDoc) => Promise<void> | void;
+}
+
+export async function reconcileOnBoot(bootId: string, opts: ReconcileOptions = {}): Promise<ReconcileResult> {
+  const interactiveKinds = new Set(opts.interactiveKinds ?? ["chat"]);
+  const retentionLimit = opts.retentionLimit ?? 500;
+
+  log.info(`[reconcileOnBoot] Starting with boot_id=${bootId}`);
+  const result: ReconcileResult = {
+    bootId,
+    runsInterrupted: 0,
+    runsReEnqueueable: 0,
+    jobsReclaimed: 0,
+    jobsInterrupted: 0,
+    runsPruned: 0,
+    jobsPruned: 0,
+  };
+
+  // 1. harness_agentRuns: any "running" row is orphaned at boot — HiveDB is
+  // single-process and this process just started, so no run can actually be
+  // executing.
+  try {
+    const runsCol = await col<HarnessRunDoc>(AGENT_RUNS_COLLECTION);
+    const runningRuns = await runsCol.findBy("status", "running");
+    for (const entry of runningRuns) {
+      const run = entry.doc;
+      if (interactiveKinds.has(run.kind)) {
+        await interruptRun(run.id, "Process restarted while an interactive run was in flight");
+        result.runsInterrupted++;
+        try {
+          await opts.onInteractiveInterrupted?.(run);
+        } catch {
+          // non-critical
+        }
+      } else {
+        await interruptRun(run.id, "Process restarted — job will be re-enqueued if durable");
+        result.runsReEnqueueable++;
+      }
+    }
+    if (result.runsInterrupted > 0 || result.runsReEnqueueable > 0) {
+      log.info(`[reconcileOnBoot] ${result.runsInterrupted} interactive runs interrupted, ${result.runsReEnqueueable} durable runs flagged for re-enqueue`);
+    }
+  } catch (err) {
+    log.warn(`[reconcileOnBoot] Failed to repair agentRuns: ${(err as Error).message}`);
+  }
+
+  // 2. harness_jobQueue: any "running" row is orphaned at boot (same
+  // single-process argument as above) → reclaim (pending) or interrupt,
+  // ignoring the lease.
+  try {
+    const jobsCol = await col<JobDoc>(JOB_QUEUE_COLLECTION);
+    const runningJobs = await jobsCol.findBy("status", "running");
+    for (const entry of runningJobs) {
+      const doc = await reclaimOrInterrupt(entry.doc.id, { force: true });
+      if (doc?.status === "pending") result.jobsReclaimed++;
+      else if (doc?.status === "interrupted") result.jobsInterrupted++;
+    }
+    if (result.jobsReclaimed > 0 || result.jobsInterrupted > 0) {
+      log.info(`[reconcileOnBoot] ${result.jobsReclaimed} jobs reclaimed to pending, ${result.jobsInterrupted} jobs interrupted (attempts exhausted)`);
+    }
+  } catch (err) {
+    log.warn(`[reconcileOnBoot] Failed to repair jobQueue: ${(err as Error).message}`);
+  }
+
+  // 3. Retention cap: keep only the most recent N agentRuns/jobs per thread/run.
+  try {
+    const runsCol = await col<HarnessRunDoc>(AGENT_RUNS_COLLECTION);
+    const allRuns = await runsCol.scan({});
+    const runsByThread = new Map<string, typeof allRuns>();
+    for (const entry of allRuns) {
+      const key = entry.doc.thread_id ?? entry.doc.agent_id ?? "_default";
+      const list = runsByThread.get(key) ?? [];
+      list.push(entry);
+      runsByThread.set(key, list);
+    }
+    for (const [, runs] of runsByThread) {
+      if (runs.length <= retentionLimit) continue;
+      const sorted = runs.sort((a, b) => (b.doc.created_at ?? 0) - (a.doc.created_at ?? 0));
+      for (const entry of sorted.slice(retentionLimit)) {
+        await runsCol.delete(entry.id);
+        result.runsPruned++;
+      }
+    }
+    if (result.runsPruned > 0) {
+      log.info(`[reconcileOnBoot] Retention: pruned ${result.runsPruned} old agentRuns (cap=${retentionLimit}/thread)`);
+    }
+
+    const jobsCol = await col<JobDoc>(JOB_QUEUE_COLLECTION);
+    const allJobs = await jobsCol.scan({});
+    const jobsByRun = new Map<string, typeof allJobs>();
+    for (const entry of allJobs) {
+      const key = entry.doc.run_id ?? "_default";
+      const list = jobsByRun.get(key) ?? [];
+      list.push(entry);
+      jobsByRun.set(key, list);
+    }
+    for (const [, jobs] of jobsByRun) {
+      if (jobs.length <= retentionLimit) continue;
+      const sorted = jobs.sort((a, b) => (b.doc.created_at ?? 0) - (a.doc.created_at ?? 0));
+      for (const entry of sorted.slice(retentionLimit)) {
+        await jobsCol.delete(entry.id);
+        result.jobsPruned++;
+      }
+    }
+    if (result.jobsPruned > 0) {
+      log.info(`[reconcileOnBoot] Retention: pruned ${result.jobsPruned} old jobs (cap=${retentionLimit}/run)`);
+    }
+  } catch (err) {
+    log.warn(`[reconcileOnBoot] Failed to enforce retention cap: ${(err as Error).message}`);
+  }
+
+  log.info(`[reconcileOnBoot] Done`, result);
+  return result;
+}

package/packages/core/src/harness/run-epoch.ts

@@ -0,0 +1,32 @@
+/**
+ * Fixed-worker epoch (harness-engineering concept): the exact
+ * provider/model/app-version/tool-catalog combination a run executed under.
+ * A model or tool-catalog change is a requalification signal — proof
+ * packets from different epochs shouldn't be compared as if the "worker"
+ * were unchanged.
+ */
+
+export interface RunEpoch {
+  provider: string;
+  model: string;
+  /** Caller-supplied version identifier (e.g. the host app's package version) — the harness doesn't assume its own version is what matters. */
+  app_version: string;
+  tool_catalog_hash: string;
+}
+
+/** Stable non-cryptographic hash (djb2) over sorted tool names — a cheap fingerprint of the active tool catalog. */
+function hashToolNames(names: string[]): string {
+  const sorted = [...names].sort().join(",");
+  let hash = 5381;
+  for (let i = 0; i < sorted.length; i++) hash = ((hash * 33) ^ sorted.charCodeAt(i)) >>> 0;
+  return hash.toString(16);
+}
+
+export function buildRunEpoch(opts: { provider: string; model: string; appVersion: string; toolNames: string[] }): RunEpoch {
+  return {
+    provider: opts.provider,
+    model: opts.model,
+    app_version: opts.appVersion,
+    tool_catalog_hash: hashToolNames(opts.toolNames),
+  };
+}

package/packages/core/src/harness/run-store.ts

@@ -0,0 +1,334 @@
+/**
+ * run-store — persistent checkpoint + lease for harness runs. Ported from
+ * `hive`'s agent/run-store.ts.
+ *
+ * A HarnessRunDoc tracks the lifecycle of a single durable agent invocation
+ * (chat turn, worker task, goal run). Its checkpoint (state_json) allows
+ * resuming after a crash: messages, iteration count, token totals and
+ * pending tool calls are persisted after every round-trip — when the host
+ * app chooses to call `checkpoint()` from its own agent loop (this module
+ * does not wire itself into `AgentRunner` automatically).
+ *
+ * All write operations use OCC (expectedVersion). Only the owning loop
+ * should write to a run; single-writer pattern keeps contention minimal.
+ */
+
+import { col, updateDoc, nextId } from "./db-helpers";
+import type { HarnessRunDoc } from "./collections";
+import { getBootId } from "./boot-id";
+import { logger } from "../utils/logger";
+import type { RunEpoch } from "./run-epoch";
+
+const log = logger.child("harness:run-store");
+
+const COLLECTION = "harness_agentRuns";
+const MAX_STATE_BYTES = 1_500_000;
+
+let leaseRenewIntervalMs = 30_000;
+let leaseDurationMs = 2 * 60 * 1000;
+
+/** Override the run lease duration / renewal interval (defaults: 2min / 30s). */
+export function setRunLeaseConfig(opts: { leaseDurationMs?: number; leaseRenewIntervalMs?: number }): void {
+  if (opts.leaseDurationMs !== undefined) leaseDurationMs = opts.leaseDurationMs;
+  if (opts.leaseRenewIntervalMs !== undefined) leaseRenewIntervalMs = opts.leaseRenewIntervalMs;
+}
+
+export interface RunCheckpointState {
+  version: 1
+  messages: unknown[]
+  iterations: number
+  totalInputTokens: number
+  totalOutputTokens: number
+  lastToolSignature?: string
+  consecutiveRepeat?: number
+  idleIterations?: number
+  injectedToolNames?: string[]
+  systemPromptSkillSections?: string[]
+}
+
+/** Whole-job acceptance criterion (harness-engineering "proof" concept). */
+export interface AcceptanceCriterion {
+  id: string
+  description: string
+  /** Deterministic tool to check this specific criterion; falls back to LLM judgment when absent. */
+  checkTool?: string | null
+}
+
+export interface CreateRunInput {
+  thread_id: string
+  agent_id: string
+  user_id: string
+  channel: string | null
+  kind: string
+  max_iterations: number
+  max_turns?: number | null
+  max_tokens?: number | null
+  goal?: string | null
+  goal_check_tool?: string | null
+  resume_policy?: HarnessRunDoc["resume_policy"]
+  acceptance?: AcceptanceCriterion[]
+  epoch?: RunEpoch
+}
+
+export async function createRun(input: CreateRunInput): Promise<HarnessRunDoc> {
+  const id = crypto.randomUUID().replace(/-/g, "").slice(0, 16);
+  const now = Date.now();
+  const bootId = getBootId();
+  const doc: HarnessRunDoc = {
+    id,
+    thread_id: input.thread_id,
+    agent_id: input.agent_id,
+    user_id: input.user_id,
+    channel: input.channel,
+    kind: input.kind,
+    status: "running",
+    iterations_used: 0,
+    max_iterations: input.max_iterations,
+    turns_used: 0,
+    max_turns: input.max_turns ?? null,
+    tokens_used: 0,
+    max_tokens: input.max_tokens ?? null,
+    goal: input.goal ?? null,
+    goal_check_tool: input.goal_check_tool ?? null,
+    goal_attempts: 0,
+    state_json: "",
+    state_bytes: 0,
+    pending_tool_calls_json: null,
+    checkpointed_at: now,
+    boot_id: bootId,
+    lease_expires_at: now + leaseDurationMs,
+    resume_policy: input.resume_policy ?? "resume",
+    acceptance_json: input.acceptance ? JSON.stringify(input.acceptance) : null,
+    epoch_json: input.epoch ? JSON.stringify(input.epoch) : null,
+    error: null,
+    created_at: now,
+    updated_at: now,
+    finished_at: null,
+  };
+  const c = await col<HarnessRunDoc>(COLLECTION);
+  await c.put(id, doc, { expectedVersion: 0 });
+  log.info(`[createRun] Run ${id} created (agent=${input.agent_id} kind=${input.kind})`);
+  return doc;
+}
+
+/** Save a checkpoint to the run: serialize messages, trim state if too big. */
+export async function checkpoint(
+  runId: string,
+  state: RunCheckpointState,
+  pendingToolCalls?: unknown[] | null
+): Promise<HarnessRunDoc> {
+  const serialized = JSON.stringify(state);
+  let stateJson = serialized;
+  let stateBytes = new TextEncoder().encode(serialized).length;
+
+  if (stateBytes > MAX_STATE_BYTES) {
+    stateJson = truncateState(state);
+    stateBytes = new TextEncoder().encode(stateJson).length;
+  }
+
+  const patch: Partial<HarnessRunDoc> = {
+    state_json: stateJson,
+    state_bytes: stateBytes,
+    pending_tool_calls_json: pendingToolCalls ? JSON.stringify(pendingToolCalls) : null,
+    checkpointed_at: Date.now(),
+    iterations_used: state.iterations,
+    tokens_used: state.totalInputTokens + state.totalOutputTokens,
+    lease_expires_at: Date.now() + leaseDurationMs,
+    boot_id: getBootId(),
+    updated_at: Date.now(),
+  };
+
+  return updateDoc<HarnessRunDoc>(COLLECTION, runId, patch);
+}
+
+export async function bumpTurn(runId: string, tokensDelta: number): Promise<HarnessRunDoc> {
+  const existing = await getRun(runId);
+  if (!existing) throw new Error(`Run ${runId} not found`);
+  return updateDoc<HarnessRunDoc>(COLLECTION, runId, {
+    turns_used: existing.turns_used + 1,
+    tokens_used: existing.tokens_used + tokensDelta,
+    lease_expires_at: Date.now() + leaseDurationMs,
+    updated_at: Date.now(),
+  });
+}
+
+export async function completeRun(runId: string, finalContent?: string): Promise<void> {
+  const now = Date.now();
+  void finalContent;
+  await updateDoc<HarnessRunDoc>(COLLECTION, runId, {
+    status: "completed",
+    state_json: "",
+    state_bytes: 0,
+    pending_tool_calls_json: null,
+    lease_expires_at: now,
+    finished_at: now,
+    updated_at: now,
+  } as Partial<HarnessRunDoc>);
+  log.info(`[completeRun] Run ${runId} completed`);
+}
+
+export async function failRun(runId: string, error: string): Promise<void> {
+  const now = Date.now();
+  await updateDoc<HarnessRunDoc>(COLLECTION, runId, {
+    status: "failed",
+    error,
+    lease_expires_at: now,
+    finished_at: now,
+    updated_at: now,
+    state_json: "",
+    state_bytes: 0,
+    pending_tool_calls_json: null,
+  });
+  log.warn(`[failRun] Run ${runId} failed: ${error}`);
+}
+
+export async function interruptRun(runId: string, reason: string): Promise<void> {
+  const now = Date.now();
+  await updateDoc<HarnessRunDoc>(COLLECTION, runId, {
+    status: "interrupted",
+    error: reason,
+    lease_expires_at: now,
+    finished_at: now,
+    updated_at: now,
+  });
+  log.warn(`[interruptRun] Run ${runId} interrupted: ${reason}`);
+}
+
+/**
+ * Take ownership of an existing run before (re-)executing it. After a crash,
+ * reconcile leaves the row "interrupted" with the dead process's boot_id;
+ * both must be reset before resuming.
+ */
+export async function reclaimRun(runId: string): Promise<void> {
+  const now = Date.now();
+  await updateDoc<HarnessRunDoc>(COLLECTION, runId, {
+    status: "running",
+    boot_id: getBootId(),
+    lease_expires_at: now + leaseDurationMs,
+    error: null,
+    finished_at: null,
+    updated_at: now,
+  });
+}
+
+export async function getRun(runId: string): Promise<HarnessRunDoc | null> {
+  const c = await col<HarnessRunDoc>(COLLECTION);
+  const entry = await c.get(runId);
+  return entry ? entry.doc : null;
+}
+
+export async function findRunsByStatus(status: HarnessRunDoc["status"]): Promise<HarnessRunDoc[]> {
+  const c = await col<HarnessRunDoc>(COLLECTION);
+  const entries = await c.findBy("status", status);
+  return entries.map((e) => e.doc);
+}
+
+export async function findRunsByThread(threadId: string): Promise<HarnessRunDoc[]> {
+  const c = await col<HarnessRunDoc>(COLLECTION);
+  const entries = await c.findBy("thread_id", threadId);
+  return entries.map((e) => e.doc);
+}
+
+export async function findExpiredRuns(): Promise<HarnessRunDoc[]> {
+  const running = await findRunsByStatus("running");
+  const now = Date.now();
+  return running.filter((r) => r.lease_expires_at < now);
+}
+
+export function deserializeAcceptance(run: HarnessRunDoc): AcceptanceCriterion[] | null {
+  if (!run.acceptance_json) return null;
+  try {
+    return JSON.parse(run.acceptance_json) as AcceptanceCriterion[];
+  } catch {
+    log.warn(`[deserializeAcceptance] Failed to parse acceptance_json for run ${run.id}`);
+    return null;
+  }
+}
+
+export function deserializeEpoch(run: HarnessRunDoc): RunEpoch | null {
+  if (!run.epoch_json) return null;
+  try {
+    return JSON.parse(run.epoch_json) as RunEpoch;
+  } catch {
+    log.warn(`[deserializeEpoch] Failed to parse epoch_json for run ${run.id}`);
+    return null;
+  }
+}
+
+/** Deserialize a checkpoint, or null if the run has no checkpoint. */
+export function deserializeCheckpoint(run: HarnessRunDoc): RunCheckpointState | null {
+  if (!run.state_json) return null;
+  try {
+    const raw = JSON.parse(run.state_json);
+    if (raw.version !== 1) return null;
+    return raw as RunCheckpointState;
+  } catch {
+    log.warn(`[deserializeCheckpoint] Failed to parse state_json for run ${run.id}`);
+    return null;
+  }
+}
+
+function truncateState(state: RunCheckpointState): string {
+  const messages = [...state.messages] as Array<Record<string, unknown>>;
+  const keepLastN = 8;
+  const cutoff = messages.length - keepLastN;
+
+  for (let i = 0; i < cutoff; i++) {
+    const msg = messages[i];
+    if (msg.role === "tool" && typeof msg.content === "string" && msg.content.length > 200) {
+      messages[i] = { ...msg, content: `[Truncated: ${(msg.content as string).substring(0, 200)}...]` };
+    }
+    if (msg.role === "assistant" && typeof msg.content === "string" && (msg.content as string).length > 500) {
+      messages[i] = { ...msg, content: (msg.content as string).substring(0, 500) + "[...]" };
+    }
+  }
+
+  return JSON.stringify({ ...state, messages });
+}
+
+// ─── Lease renewal timer ────────────────────────────────────────────────────
+
+const leaseTimers: Map<string, ReturnType<typeof setInterval>> = new Map();
+
+export function startLeaseRenewal(runId: string): void {
+  if (leaseTimers.has(runId)) return;
+  const timer = setInterval(async () => {
+    try {
+      const run = await getRun(runId);
+      if (!run || run.status !== "running") {
+        stopLeaseRenewal(runId);
+        return;
+      }
+      await updateDoc<HarnessRunDoc>(COLLECTION, runId, {
+        lease_expires_at: Date.now() + leaseDurationMs,
+        updated_at: Date.now(),
+      } as Partial<HarnessRunDoc>);
+    } catch (err) {
+      log.warn(`[startLeaseRenewal] Failed to renew lease for ${runId}: ${(err as Error).message}`);
+    }
+  }, leaseRenewIntervalMs);
+  leaseTimers.set(runId, timer);
+}
+
+export function stopLeaseRenewal(runId: string): void {
+  const timer = leaseTimers.get(runId);
+  if (timer) {
+    clearInterval(timer);
+    leaseTimers.delete(runId);
+  }
+}
+
+export function stopAllLeaseRenewals(): void {
+  for (const [, timer] of leaseTimers) clearInterval(timer);
+  leaseTimers.clear();
+}
+
+export async function ensureRunStoreIndexes(): Promise<void> {
+  const c = await col<HarnessRunDoc>(COLLECTION);
+  await c.createIndex("status");
+  await c.createIndex("thread_id");
+  await c.createIndex("agent_id");
+  await c.createIndex("kind");
+}
+
+export { COLLECTION as AGENT_RUNS_COLLECTION };

package/packages/core/src/index.ts

@@ -92,3 +92,9 @@ export type { WorkerConfig, WorkerInstance, WorkerChunk, WorkerPoolConfig, PoolT
 // ─── Utils ───────────────────────────────────────────────────────────────────
 export { logger } from "./utils/index.ts";
 export { retry } from "./utils/retry.ts";
+
+// ─── Harness (durable task execution) ───────────────────────────────────────
+// Namespaced to avoid flooding the top-level barrel with ~50 harness exports —
+// see docs/HIVE-HARNESS.md. Also available as a flat import from
+// "@johpaz/hive-sdk/harness".
+export * as harness from "./harness/index.ts";

package/packages/core/src/memory/Scratchpad.test.ts

@@ -1,47 +1,49 @@
 import { describe, it, expect, beforeAll, afterAll } from "bun:test";
 import { Scratchpad } from "./Scratchpad.ts";
-import { getDb, initializeDatabase, DatabaseService, dbService } from "../storage/SQLiteStorage.ts";
+import { initializeDatabase, dbService } from "../storage/SQLiteStorage.ts";
+import { getHiveDB, closeHiveDB } from "../storage/HiveDBStorage.ts";
 
 describe("Scratchpad", () => {
 	let pad: Scratchpad;
 
 	beforeAll(async () => {
-		await initializeDatabase();
-		const db = getDb();
-		pad = new Scratchpad(db);
+		initializeDatabase();
+		await getHiveDB();
+		pad = new Scratchpad();
 	});
 
 	afterAll(() => {
+		closeHiveDB();
 		dbService.close();
 	});
 
 	const THREAD = "test-thread";
 
-	it("writes and reads a note", () => {
-		pad.write(THREAD, "test-1", "hello world");
-		const value = pad.read(THREAD, "test-1");
+	it("writes and reads a note", async () => {
+		await pad.write(THREAD, "test-1", "hello world");
+		const value = await pad.read(THREAD, "test-1");
 		expect(value).toBe("hello world");
 	});
 
-	it("lists notes as key-value map", () => {
-		pad.write(THREAD, "list-a", "aaa");
-		pad.write(THREAD, "list-b", "bbb");
-		const notes = pad.list(THREAD);
+	it("lists notes as key-value map", async () => {
+		await pad.write(THREAD, "list-a", "aaa");
+		await pad.write(THREAD, "list-b", "bbb");
+		const notes = await pad.list(THREAD);
 		expect(notes["list-a"]).toBe("aaa");
 		expect(notes["list-b"]).toBe("bbb");
 	});
 
-	it("deletes a note", () => {
-		pad.write(THREAD, "to-delete", "delete me");
-		pad.delete(THREAD, "to-delete");
-		const value = pad.read(THREAD, "to-delete");
-		expect(value).toBeNull();
+	it("deletes a note", async () => {
+		await pad.write(THREAD, "to-delete", "delete me");
+		await pad.delete(THREAD, "to-delete");
+		const value = await pad.read(THREAD, "to-delete");
+		expect(value).toBeUndefined();
 	});
 
-	it("clear removes all notes for a thread", () => {
-		pad.write(THREAD, "clear-a", "a");
-		pad.write(THREAD, "clear-b", "b");
-		pad.clear(THREAD);
-		expect(Object.keys(pad.list(THREAD)).length).toBe(0);
+	it("clear removes all notes for a thread", async () => {
+		await pad.write(THREAD, "clear-a", "a");
+		await pad.write(THREAD, "clear-b", "b");
+		await pad.clear(THREAD);
+		expect(Object.keys(await pad.list(THREAD)).length).toBe(0);
 	});
 });