@rohirik/openltm-core 2.8.1 → 2.9.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rohirik/openltm-core",
-  "version": "2.8.1",
+  "version": "2.9.1",
   "description": "Shared LTM storage engine — path-agnostic SQLite core used by Claude Code, OpenCode, and Pi adapters",
   "type": "module",
   "main": "./src/index.ts",

package/src/__tests__/events/crossProcess.test.ts

@@ -14,6 +14,7 @@ import {
   MEMORY_ADDED,
 } from "../../events/index.js";
 import { _resetHonkerForTesting } from "../../lib/honker.js";
+import { resetCapabilitiesForTesting } from "../../extensions.js";
 
 function seedDb(): Database {
   const db = new Database(":memory:");
@@ -25,6 +26,9 @@ describe("cross-process sync — flag + dormant contract (no honker)", () => {
   beforeEach(() => {
     _resetHonkerForTesting();
     delete process.env["LTM_HONKER_EXT"];
+    // Reset cached caps so a prior test's honker=true (vendored binary is
+    // discoverable here) does not leak in — keeps this the dormant contract.
+    resetCapabilitiesForTesting();
   });
   afterEach(() => {
     _resetHonkerForTesting();

package/src/__tests__/events/index.test.ts

@@ -7,11 +7,15 @@
 import { describe, it, expect, beforeEach } from "bun:test";
 import { notifyLtm, startLtmListener, LTM_CHANNEL } from "../../events/index.js";
 import { _resetHonkerForTesting } from "../../lib/honker.js";
+import { resetCapabilitiesForTesting } from "../../extensions.js";
 
 describe("events — dormant path (no honker)", () => {
   beforeEach(() => {
     _resetHonkerForTesting();
     delete process.env["LTM_HONKER_EXT"];
+    // Reset cached caps so a prior test's honker=true (vendored binary is
+    // discoverable here) does not leak in — keeps this the dormant contract.
+    resetCapabilitiesForTesting();
   });
 
   it("exposes the stable channel name", () => {

package/src/__tests__/extensions.test.ts

@@ -2,6 +2,7 @@ import { describe, it, expect, beforeEach } from "bun:test";
 import { Database } from "bun:sqlite";
 import {
   locateSystemSqlite,
+  locateHonkerExt,
   ensureCustomSqlite,
   loadExtensions,
   getCapabilities,
@@ -32,14 +33,27 @@ describe("extensions — capability probe", () => {
     expect(typeof caps.honker).toBe("boolean");
   });
 
-  it("honker is false when no LTM_HONKER_EXT binary is configured", () => {
-    const prev = process.env["LTM_HONKER_EXT"];
-    delete process.env["LTM_HONKER_EXT"];
+  it("honker is false when force-disabled via LTM_DISABLE_HONKER", () => {
+    const prev = process.env["LTM_DISABLE_HONKER"];
+    process.env["LTM_DISABLE_HONKER"] = "1";
     ensureCustomSqlite();
     const db = new Database(":memory:");
     const caps = loadExtensions(db);
     expect(caps.honker).toBe(false);
-    if (prev) process.env["LTM_HONKER_EXT"] = prev;
+    if (prev === undefined) delete process.env["LTM_DISABLE_HONKER"];
+    else process.env["LTM_DISABLE_HONKER"] = prev;
+  });
+
+  it("honker auto-loads when a vendored libhonker_ext binary is discoverable", () => {
+    // Mirrors the vec test: activation needs customSqlite (process-global, only
+    // before the first DB open) AND a discoverable binary. Skip when either is
+    // unavailable — that is the graceful-degradation path, not a failure.
+    if (locateHonkerExt() === null || process.env["LTM_DISABLE_HONKER"]) return;
+    ensureCustomSqlite();
+    const db = new Database(":memory:");
+    const caps = loadExtensions(db);
+    if (!caps.customSqlite) return;
+    expect(caps.honker).toBe(true);
   });
 
   it("respects LTM_DISABLE_VEC — vec capability is false when force-disabled", () => {

package/src/__tests__/queue/index.test.ts

@@ -15,10 +15,15 @@ import {
 } from "../../queue/index.js";
 import { startEmbeddingWorker } from "../../queue/worker.js";
 import { isHonkerAvailable, _resetHonkerForTesting } from "../../lib/honker.js";
+import { resetCapabilitiesForTesting } from "../../extensions.js";
 
 describe("queue — dormant path (no honker)", () => {
   beforeEach(() => {
     _resetHonkerForTesting();
+    // Force the dormant contract: a prior test may have cached caps.honker=true
+    // process-wide (the vendored binary is discoverable here). Reset so
+    // getCapabilities() returns the all-false default and honker stays dormant.
+    resetCapabilitiesForTesting();
   });
 
   it("EMBED_QUEUE has a stable name", () => {

package/src/__tests__/scheduler/index.test.ts

@@ -13,11 +13,15 @@ import {
   DEFAULT_JANITOR_CRON,
 } from "../../scheduler/index.js";
 import { _resetHonkerForTesting } from "../../lib/honker.js";
+import { resetCapabilitiesForTesting } from "../../extensions.js";
 
 describe("scheduler — dormant path (no honker)", () => {
   beforeEach(() => {
     _resetHonkerForTesting();
     delete process.env["LTM_HONKER_EXT"];
+    // Reset cached caps so a prior test's honker=true (vendored binary is
+    // discoverable here) does not leak in — keeps this the dormant contract.
+    resetCapabilitiesForTesting();
   });
 
   it("exposes stable names + default cron", () => {

package/src/extensions.ts

@@ -13,6 +13,11 @@
  */
 import { Database } from "bun:sqlite";
 import { existsSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+
+/** Directory of this module — used to resolve the vendored Honker binary. */
+const MODULE_DIR = dirname(fileURLToPath(import.meta.url));
 
 export interface Capabilities {
   /** A system extension-enabled SQLite is active for this process. */
@@ -48,9 +53,9 @@ function envDisabled(name: string): boolean {
   return v === "1" || v === "true";
 }
 
-/** Locate a system extension-enabled libsqlite3, or null if none found. */
-export function locateSystemSqlite(): string | null {
-  for (const p of systemSqliteCandidates()) {
+/** First candidate path that exists on disk, or null. Never throws. */
+function firstExisting(candidates: string[]): string | null {
+  for (const p of candidates) {
     try {
       if (existsSync(p)) return p;
     } catch {
@@ -60,6 +65,32 @@ export function locateSystemSqlite(): string | null {
   return null;
 }
 
+/** Locate a system extension-enabled libsqlite3, or null if none found. */
+export function locateSystemSqlite(): string | null {
+  return firstExisting(systemSqliteCandidates());
+}
+
+// Probe order: explicit override first, then the vendored binary for this
+// platform (packages/openltm-core/vendor/honker/<platform>/libhonker_ext.<ext>).
+function honkerExtCandidates(): string[] {
+  const out: string[] = [];
+  const override = process.env["LTM_HONKER_EXT"];
+  if (override) out.push(override);
+  const platform = `${process.platform}-${process.arch}`;
+  const suffix = process.platform === "darwin" ? "dylib" : "so";
+  out.push(join(MODULE_DIR, "..", "vendor", "honker", platform, `libhonker_ext.${suffix}`));
+  return out;
+}
+
+/**
+ * Locate the Honker loadable extension, or null if none is available for this
+ * platform. Mirrors locateSystemSqlite(): LTM_HONKER_EXT override wins, then the
+ * vendored per-platform binary. A null result means Honker stays dormant.
+ */
+export function locateHonkerExt(): string | null {
+  return firstExisting(honkerExtCandidates());
+}
+
 /**
  * Switch the process to a system extension-enabled SQLite. Idempotent and
  * never throws. Must run before the first Database is constructed to take
@@ -74,8 +105,16 @@ export function ensureCustomSqlite(): boolean {
   const lib = locateSystemSqlite();
   if (!lib) return false;
   try {
-    (Database as unknown as { setCustomSQLite: (p: string) => void }).setCustomSQLite(lib);
+    const DB = Database as unknown as { setCustomSQLite: (p: string) => void };
+    DB.setCustomSQLite(lib);
     _customSqliteApplied = true;
+    // setCustomSQLite is a once-per-process global (Bun throws "SQLite already
+    // loaded" on a second call). honker-bun's open() calls it again on its own
+    // connection and would throw — silently killing the honker handle even
+    // though the extension-enabled SQLite is already active process-wide. Now
+    // that we've loaded it, neutralise further calls so honker-bun (and any
+    // other consumer) no-ops instead of throwing.
+    DB.setCustomSQLite = () => {};
     return true;
   } catch {
     return false;
@@ -99,8 +138,8 @@ function loadVec(db: Database): boolean {
 }
 
 function loadHonker(db: Database): boolean {
-  const ext = process.env["LTM_HONKER_EXT"];
-  if (!ext || !existsSync(ext)) return false;
+  const ext = locateHonkerExt();
+  if (!ext) return false;
   try {
     db.loadExtension(ext);
     return true;
@@ -114,12 +153,14 @@ function loadHonker(db: Database): boolean {
  * capabilities for the process. Never throws.
  *
  * @param opts.vec    attempt sqlite-vec (default true; env LTM_DISABLE_VEC wins)
- * @param opts.honker attempt Honker (default false; env LTM_DISABLE_HONKER wins,
- *                    and a libhonker_ext path must be set via LTM_HONKER_EXT)
+ * @param opts.honker attempt Honker (default: auto-on when a libhonker_ext binary
+ *                    is discoverable via locateHonkerExt(); env LTM_DISABLE_HONKER
+ *                    force-disables, and LTM_HONKER_EXT overrides the binary path)
  */
 export function loadExtensions(db: Database, opts?: { vec?: boolean; honker?: boolean }): Capabilities {
   const wantVec = (opts?.vec ?? true) && !envDisabled("LTM_DISABLE_VEC");
-  const wantHonker = (opts?.honker ?? false) && !envDisabled("LTM_DISABLE_HONKER");
+  const wantHonker =
+    (opts?.honker ?? locateHonkerExt() !== null) && !envDisabled("LTM_DISABLE_HONKER");
 
   const customSqlite = ensureCustomSqlite();
   const vec = customSqlite && wantVec ? loadVec(db) : false;

package/src/lib/honker.ts

@@ -13,7 +13,7 @@
  * pre-Honker behaviour (inline embed, HTTP poll, file-watcher).
  */
 import type { HonkerDb, HonkerModule } from "./honkerTypes.js";
-import { getCapabilities, locateSystemSqlite } from "../extensions.js";
+import { getCapabilities, locateSystemSqlite, locateHonkerExt } from "../extensions.js";
 import { DB_PATH } from "../shared-db.js";
 
 let _handle: HonkerDb | null | undefined = undefined;
@@ -31,7 +31,7 @@ export function getHonker(): HonkerDb | null {
 
 function openHonker(): HonkerDb | null {
   if (!getCapabilities().honker) return null;
-  const ext = process.env["LTM_HONKER_EXT"];
+  const ext = locateHonkerExt();
   if (!ext) return null;
   try {
     // eslint-disable-next-line @typescript-eslint/no-var-requires