@loreai/core 0.17.1 → 0.18.0

package/src/curator.ts

@@ -3,6 +3,7 @@ import * as temporal from "./temporal";
 import * as ltm from "./ltm";
 import * as log from "./log";
 import { CURATOR_SYSTEM, curatorUser, CONSOLIDATION_SYSTEM, consolidationUser } from "./prompt";
+import { detectAndFormat } from "./instruction-detect";
 import type { LLMClient } from "./types";
 
 /**
@@ -11,9 +12,9 @@ import type { LLMClient } from "./types";
  * The curator prompt also instructs the model to stay within this limit,
  * so truncation is a last-resort safety net.
  */
-const MAX_ENTRY_CONTENT_LENGTH = 1200;
+export const MAX_ENTRY_CONTENT_LENGTH = 1200;
 
-type CuratorOp =
+export type CuratorOp =
   | {
       op: "create";
       category: string;
@@ -25,7 +26,11 @@ type CuratorOp =
   | { op: "update"; id: string; content?: string; confidence?: number }
   | { op: "delete"; id: string; reason: string };
 
-function parseOps(text: string): CuratorOp[] {
+/**
+ * Parse the LLM's JSON response into typed curator ops.
+ * Handles markdown fences and filters invalid entries.
+ */
+export function parseOps(text: string): CuratorOp[] {
   const cleaned = text
     .trim()
     .replace(/^```json?\s*/i, "")
@@ -45,58 +50,29 @@ function parseOps(text: string): CuratorOp[] {
   }
 }
 
-// Track which messages we've already curated — per session to prevent
-// cross-session leaking (curation on session A advancing the timestamp
-// past session B's messages, causing B's curation to find < 3 recent).
-const lastCuratedAt = new Map<string, number>();
-
-export async function run(input: {
-  llm: LLMClient;
-  projectPath: string;
-  sessionID: string;
-  model?: { providerID: string; modelID: string };
-}): Promise<{ created: number; updated: number; deleted: number }> {
-  const cfg = config();
-  if (!cfg.curator.enabled) return { created: 0, updated: 0, deleted: 0 };
-
-  // Get recent messages since last curation
-  const all = temporal.bySession(input.projectPath, input.sessionID);
-  const sessionCuratedAt = lastCuratedAt.get(input.sessionID) ?? 0;
-  const recent = all.filter((m) => m.created_at > sessionCuratedAt);
-  if (recent.length < 3) return { created: 0, updated: 0, deleted: 0 };
-
-  const text = recent.map((m) => `[${m.role}] ${m.content}`).join("\n\n");
-  const existing = ltm.forProject(input.projectPath, false);
-  const existingForPrompt = existing.map((e) => ({
-    id: e.id,
-    category: e.category,
-    title: e.title,
-    content: e.content,
-  }));
-
-  const userContent = curatorUser({
-    messages: text,
-    existing: existingForPrompt,
-  });
-  const model = input.model ?? cfg.model;
-  const responseText = await input.llm.prompt(
-    CURATOR_SYSTEM,
-    userContent,
-    { model, workerID: "lore-curator", thinking: false, sessionID: input.sessionID, maxTokens: 2048 },
-  );
-  if (!responseText) return { created: 0, updated: 0, deleted: 0 };
-
-  const ops = parseOps(responseText);
+/**
+ * Apply a list of curator ops (create/update/delete) to the knowledge DB.
+ * Shared by both the live curator and the conversation import system.
+ *
+ * @returns Counts of applied operations.
+ */
+export function applyOps(
+  ops: CuratorOp[],
+  input: {
+    projectPath?: string;
+    sessionID?: string;
+    /** If true, skip "create" ops (used by consolidation). */
+    skipCreate?: boolean;
+  },
+): { created: number; updated: number; deleted: number } {
   let created = 0;
   let updated = 0;
   let deleted = 0;
-
   const idsToSync: string[] = [];
 
   for (const op of ops) {
     if (op.op === "create") {
-      // Truncate oversized content — the model should stay within the prompt's
-      // 500-word limit, but enforce it here as a hard safety net.
+      if (input.skipCreate) continue;
       const content =
         op.content.length > MAX_ENTRY_CONTENT_LENGTH
           ? op.content.slice(0, MAX_ENTRY_CONTENT_LENGTH) +
@@ -139,10 +115,90 @@ export async function run(input: {
     ltm.syncRefs(id);
   }
 
-  lastCuratedAt.set(input.sessionID, Date.now());
   return { created, updated, deleted };
 }
 
+// Track which messages we've already curated — per session to prevent
+// cross-session leaking (curation on session A advancing the timestamp
+// past session B's messages, causing B's curation to find < 3 recent).
+const lastCuratedAt = new Map<string, number>();
+
+export async function run(input: {
+  llm: LLMClient;
+  projectPath: string;
+  sessionID: string;
+  model?: { providerID: string; modelID: string };
+}): Promise<{ created: number; updated: number; deleted: number }> {
+  const cfg = config();
+  if (!cfg.curator.enabled) return { created: 0, updated: 0, deleted: 0 };
+
+  // Get recent messages since last curation
+  const all = temporal.bySession(input.projectPath, input.sessionID);
+  const sessionCuratedAt = lastCuratedAt.get(input.sessionID) ?? 0;
+  const recent = all.filter((m) => m.created_at > sessionCuratedAt);
+  if (recent.length < 3) return { created: 0, updated: 0, deleted: 0 };
+
+  const text = recent.map((m) => `[${m.role}] ${m.content}`).join("\n\n");
+  const existing = ltm.forProject(input.projectPath, false);
+  const existingForPrompt = existing.map((e) => ({
+    id: e.id,
+    category: e.category,
+    title: e.title,
+    content: e.content,
+  }));
+
+  const baseUserContent = curatorUser({
+    messages: text,
+    existing: existingForPrompt,
+  });
+
+  // Detect repeated instructions across prior sessions and append as
+  // additional context for the curator. This is async (may embed candidates)
+  // but fast — typically <250ms for 5 candidates with local embeddings.
+  let crossSessionContext = "";
+  try {
+    crossSessionContext = await detectAndFormat({
+      projectPath: input.projectPath,
+      sessionID: input.sessionID,
+    });
+  } catch (err) {
+    log.warn("instruction-detect failed (non-fatal):", err);
+  }
+
+  const userContent = baseUserContent + crossSessionContext;
+  const model = input.model ?? cfg.model;
+  const responseText = await input.llm.prompt(
+    CURATOR_SYSTEM,
+    userContent,
+    { model, workerID: "lore-curator", thinking: false, sessionID: input.sessionID, maxTokens: 2048 },
+  );
+  if (!responseText) return { created: 0, updated: 0, deleted: 0 };
+
+  const ops = parseOps(responseText);
+  const result = applyOps(ops, {
+    projectPath: input.projectPath,
+    sessionID: input.sessionID,
+  });
+
+  // Post-curation dedup sweep: if the curator created new entries, check for
+  // and auto-merge any semantic duplicates it introduced. Uses embedding-based
+  // similarity when available, falls back to word-overlap.
+  if (result.created > 0) {
+    try {
+      const dupes = await ltm.deduplicate(input.projectPath, { dryRun: false });
+      if (dupes.totalRemoved > 0) {
+        log.info(`post-curation dedup: merged ${dupes.totalRemoved} duplicate entries`);
+        result.deleted += dupes.totalRemoved;
+      }
+    } catch (err) {
+      log.warn("post-curation dedup failed (non-fatal):", err);
+    }
+  }
+
+  lastCuratedAt.set(input.sessionID, Date.now());
+  return result;
+}
+
 export function resetCurationTracker(sessionID?: string) {
   if (sessionID) {
     lastCuratedAt.delete(sessionID);
@@ -190,31 +246,11 @@ export async function consolidate(input: {
   if (!responseText) return { updated: 0, deleted: 0 };
 
   const ops = parseOps(responseText);
-  let updated = 0;
-  let deleted = 0;
-
-  for (const op of ops) {
-    // Consolidation only applies update and delete — never create.
-    if (op.op === "update") {
-      const entry = ltm.get(op.id);
-      if (entry) {
-        const content =
-          op.content !== undefined && op.content.length > MAX_ENTRY_CONTENT_LENGTH
-            ? op.content.slice(0, MAX_ENTRY_CONTENT_LENGTH) +
-              " [truncated — entry too long]"
-            : op.content;
-        ltm.update(op.id, { content, confidence: op.confidence });
-        updated++;
-      }
-    } else if (op.op === "delete") {
-      const entry = ltm.get(op.id);
-      if (entry) {
-        ltm.remove(op.id);
-        deleted++;
-      }
-    }
-    // "create" ops are silently ignored — consolidation must not add entries.
-  }
+  const result = applyOps(ops, {
+    projectPath: input.projectPath,
+    sessionID: input.sessionID,
+    skipCreate: true, // Consolidation must not add entries.
+  });
 
-  return { updated, deleted };
+  return { updated: result.updated, deleted: result.deleted };
 }

package/src/data-dir.ts

@@ -0,0 +1,76 @@
+/**
+ * Shared data-directory path resolution with one-time migration from the
+ * legacy `opencode-lore` directory name to `lore`.
+ *
+ * Both `db.ts` and `log.ts` need the data directory path.  This module
+ * provides a single source of truth so the path logic is not duplicated.
+ */
+
+import { existsSync, renameSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+const OLD_DIR_NAME = "opencode-lore";
+const NEW_DIR_NAME = "lore";
+
+let migrationAttempted = false;
+
+/**
+ * Compute the XDG-compliant base directory for lore data.
+ * Respects `$XDG_DATA_HOME`, defaults to `~/.local/share`.
+ */
+function baseDir(): string {
+  return process.env.XDG_DATA_HOME || join(homedir(), ".local", "share");
+}
+
+/**
+ * Attempt a one-time migration of the legacy data directory.
+ *
+ * - Old exists, new does not → atomic `renameSync` (same filesystem).
+ * - Both exist → keep new (user already migrated or has fresh data).
+ * - Neither exists → no-op; callers create the dir via `mkdirSync`.
+ *
+ * Runs at most once per process.  Errors are swallowed — migration
+ * failure is not fatal because callers create the directory anyway.
+ */
+function migrateDataDir(): void {
+  if (migrationAttempted) return;
+  migrationAttempted = true;
+
+  // Tests use LORE_DB_PATH pointed at a temp dir; never touch the real
+  // data directory.
+  if (process.env.NODE_ENV === "test") return;
+
+  const base = baseDir();
+  const oldDir = join(base, OLD_DIR_NAME);
+  const newDir = join(base, NEW_DIR_NAME);
+
+  try {
+    if (existsSync(oldDir) && !existsSync(newDir)) {
+      renameSync(oldDir, newDir);
+      // Can't use the lore logger here (circular dep), so use stderr.
+      console.error(`[lore] migrated data directory: ${oldDir} → ${newDir}`);
+    }
+  } catch {
+    // Permission error, cross-device rename, concurrent process already
+    // renamed it, etc.  Not fatal — dataDir() returns the new path and
+    // callers create the directory if it doesn't exist yet.
+  }
+}
+
+/**
+ * Return the resolved data directory path (`~/.local/share/lore` by
+ * default), running the legacy-directory migration on the first call.
+ *
+ * **Callers are responsible for creating the directory** — this function
+ * does not call `mkdirSync`.
+ */
+export function dataDir(): string {
+  migrateDataDir();
+  return join(baseDir(), NEW_DIR_NAME);
+}
+
+/** @internal Visible for testing only — resets the one-shot guard. */
+export function _resetMigrationFlag(): void {
+  migrationAttempted = false;
+}

package/src/db.ts

@@ -1,8 +1,8 @@
 import { Database } from "#db/driver";
 import { join, dirname } from "path";
 import { mkdirSync } from "fs";
-import { homedir } from "os";
 import { getGitRemote } from "./git";
+import { dataDir } from "./data-dir";
 
 /**
  * Extract the repository name from a normalized git remote URL.
@@ -453,14 +453,70 @@ const MIGRATIONS: string[] = [
   ALTER TABLE session_state ADD COLUMN ttl_hits INTEGER NOT NULL DEFAULT 0;
   ALTER TABLE session_state ADD COLUMN batch_savings REAL NOT NULL DEFAULT 0;
   `,
+  `
+  -- Version 19: Import history for conversation import idempotency.
+  -- Tracks which external agent sessions have been imported to prevent
+  -- re-importing unchanged sources and to record user-declined imports.
+  CREATE TABLE IF NOT EXISTS import_history (
+    id TEXT PRIMARY KEY,
+    project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+    agent_name TEXT NOT NULL,
+    source_id TEXT NOT NULL,
+    source_hash TEXT NOT NULL,
+    entries_created INTEGER NOT NULL DEFAULT 0,
+    entries_updated INTEGER NOT NULL DEFAULT 0,
+    imported_at INTEGER NOT NULL,
+    UNIQUE(project_id, agent_name, source_id)
+  );
+  CREATE INDEX IF NOT EXISTS idx_import_history_project ON import_history(project_id);
+  `,
+  `
+  -- Version 20: Purge worker boilerplate from temporal messages.
+  -- Legacy gateway/plugin worker calls (distillation observer, curator,
+  -- consolidation, reflector, eval) stored their full system prompts
+  -- (containing entire conversation transcripts, up to 1.6MB each) as
+  -- temporal messages. These pollute FTS search results by matching
+  -- virtually any domain keyword. Safe to delete: their actual output
+  -- (distillations, knowledge entries) is stored in dedicated tables.
+  DELETE FROM temporal_messages WHERE content LIKE '%You are a memory observer.%'
+    OR content LIKE '%You are a long-term memory curator.%'
+    OR content LIKE '%You are a long-term memory curator performing a consolidation pass.%'
+    OR content LIKE '%You are a memory reflector.%'
+    OR content LIKE '%You are evaluating distillation quality.%';
+  `,
+  `
+  -- Version 21: Persist avoided compaction data from live sessions.
+  -- Historical estimates previously re-simulated avoided compactions from
+  -- temporal message token estimates (chars/3), missing system prompt and
+  -- tool definition overhead. Persisting the live session's real shadow
+  -- context tracking (from actual API-reported total input tokens) gives
+  -- accurate post-restart historical estimates.
+  ALTER TABLE session_state ADD COLUMN avoided_compactions INTEGER NOT NULL DEFAULT 0;
+  ALTER TABLE session_state ADD COLUMN avoided_compaction_cost REAL NOT NULL DEFAULT 0;
+  `,
+  `
+  -- Version 22: Track when conversation import was last offered/run.
+  -- NULL means import has never been offered for this project.
+  -- Used by auto-import to avoid re-prompting, and by explicit
+  -- \`lore import\` for incremental imports (only newer conversations).
+  ALTER TABLE projects ADD COLUMN last_import_at INTEGER;
+
+  -- Backfill: migrate legacy __declined__ sentinel rows so existing
+  -- users who previously declined are not re-prompted after upgrading.
+  UPDATE projects SET last_import_at = (
+    SELECT ih.imported_at FROM import_history ih
+    WHERE ih.project_id = projects.id
+      AND ih.source_id = '__declined__'
+    LIMIT 1
+  )
+  WHERE EXISTS (
+    SELECT 1 FROM import_history ih
+    WHERE ih.project_id = projects.id
+      AND ih.source_id = '__declined__'
+  );
+  `,
 ];
 
-function dataDir() {
-  const xdg = process.env.XDG_DATA_HOME;
-  const base = xdg || join(homedir(), ".local", "share");
-  return join(base, "opencode-lore");
-}
-
 /** Return the resolved path of the SQLite database file. */
 export function dbPath(): string {
   const envPath = process.env.LORE_DB_PATH;
@@ -807,6 +863,33 @@ export function isFirstRun(): boolean {
   return row.count === 0;
 }
 
+// ---------------------------------------------------------------------------
+// Conversation import tracking
+// ---------------------------------------------------------------------------
+
+/**
+ * Get the timestamp of the last conversation import offer/run for a project.
+ * Returns null if import has never been offered for this project.
+ */
+export function getLastImportAt(projectPath: string): number | null {
+  const id = ensureProject(projectPath);
+  const row = db()
+    .query("SELECT last_import_at FROM projects WHERE id = ?")
+    .get(id) as { last_import_at: number | null } | null;
+  return row?.last_import_at ?? null;
+}
+
+/**
+ * Record that conversation import was offered/run for a project.
+ * Prevents auto-import from re-prompting, and enables incremental imports.
+ */
+export function setLastImportAt(projectPath: string, timestamp: number): void {
+  const id = ensureProject(projectPath);
+  db()
+    .query("UPDATE projects SET last_import_at = ? WHERE id = ?")
+    .run(timestamp, id);
+}
+
 // ---------------------------------------------------------------------------
 // Persistent session state (error recovery)
 // ---------------------------------------------------------------------------
@@ -851,6 +934,8 @@ export type SessionCostSnapshot = {
   ttlSavings: number;
   ttlHits: number;
   batchSavings: number;
+  avoidedCompactions: number;
+  avoidedCompactionCost: number;
 };
 
 /**
@@ -863,8 +948,9 @@ export function saveSessionCosts(sessionID: string, costs: SessionCostSnapshot):
       `INSERT INTO session_state (session_id, force_min_layer, updated_at,
          conversation_cost, worker_cost, conversation_turns,
          cache_read_tokens, cache_write_tokens,
-         warmup_savings, warmup_hits, ttl_savings, ttl_hits, batch_savings)
-       VALUES (?, COALESCE((SELECT force_min_layer FROM session_state WHERE session_id = ?), 0), ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+         warmup_savings, warmup_hits, ttl_savings, ttl_hits, batch_savings,
+         avoided_compactions, avoided_compaction_cost)
+       VALUES (?, COALESCE((SELECT force_min_layer FROM session_state WHERE session_id = ?), 0), ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
        ON CONFLICT(session_id) DO UPDATE SET
          conversation_cost = excluded.conversation_cost,
          worker_cost = excluded.worker_cost,
@@ -876,6 +962,8 @@ export function saveSessionCosts(sessionID: string, costs: SessionCostSnapshot):
          ttl_savings = excluded.ttl_savings,
          ttl_hits = excluded.ttl_hits,
          batch_savings = excluded.batch_savings,
+         avoided_compactions = excluded.avoided_compactions,
+         avoided_compaction_cost = excluded.avoided_compaction_cost,
          updated_at = excluded.updated_at`,
     )
     .run(
@@ -883,6 +971,7 @@ export function saveSessionCosts(sessionID: string, costs: SessionCostSnapshot):
       costs.conversationCost, costs.workerCost, costs.conversationTurns,
       costs.cacheReadTokens, costs.cacheWriteTokens,
       costs.warmupSavings, costs.warmupHits, costs.ttlSavings, costs.ttlHits, costs.batchSavings,
+      costs.avoidedCompactions, costs.avoidedCompactionCost,
     );
 }
 
@@ -895,7 +984,8 @@ export function loadSessionCosts(sessionID: string): SessionCostSnapshot | null
     .query(
       `SELECT conversation_cost, worker_cost, conversation_turns,
               cache_read_tokens, cache_write_tokens,
-              warmup_savings, warmup_hits, ttl_savings, ttl_hits, batch_savings
+              warmup_savings, warmup_hits, ttl_savings, ttl_hits, batch_savings,
+              avoided_compactions, avoided_compaction_cost
        FROM session_state WHERE session_id = ?`,
     )
     .get(sessionID) as {
@@ -909,6 +999,8 @@ export function loadSessionCosts(sessionID: string): SessionCostSnapshot | null
       ttl_savings: number;
       ttl_hits: number;
       batch_savings: number;
+      avoided_compactions: number;
+      avoided_compaction_cost: number;
     } | null;
   if (!row) return null;
   return {
@@ -922,6 +1014,8 @@ export function loadSessionCosts(sessionID: string): SessionCostSnapshot | null
     ttlSavings: row.ttl_savings,
     ttlHits: row.ttl_hits,
     batchSavings: row.batch_savings,
+    avoidedCompactions: row.avoided_compactions,
+    avoidedCompactionCost: row.avoided_compaction_cost,
   };
 }
 
@@ -934,7 +1028,8 @@ export function loadAllSessionCosts(): Map<string, SessionCostSnapshot> {
     .query(
       `SELECT session_id, conversation_cost, worker_cost, conversation_turns,
               cache_read_tokens, cache_write_tokens,
-              warmup_savings, warmup_hits, ttl_savings, ttl_hits, batch_savings
+              warmup_savings, warmup_hits, ttl_savings, ttl_hits, batch_savings,
+              avoided_compactions, avoided_compaction_cost
        FROM session_state
        WHERE conversation_turns > 0 OR warmup_savings > 0 OR ttl_savings > 0 OR batch_savings > 0`,
     )
@@ -950,6 +1045,8 @@ export function loadAllSessionCosts(): Map<string, SessionCostSnapshot> {
       ttl_savings: number;
       ttl_hits: number;
       batch_savings: number;
+      avoided_compactions: number;
+      avoided_compaction_cost: number;
     }>;
   const result = new Map<string, SessionCostSnapshot>();
   for (const row of rows) {
@@ -964,6 +1061,8 @@ export function loadAllSessionCosts(): Map<string, SessionCostSnapshot> {
       ttlSavings: row.ttl_savings,
       ttlHits: row.ttl_hits,
       batchSavings: row.batch_savings,
+      avoidedCompactions: row.avoided_compactions,
+      avoidedCompactionCost: row.avoided_compaction_cost,
     });
   }
   return result;

package/src/distillation.ts

@@ -811,7 +811,8 @@ async function distillSegment(input: {
 
   // Fire-and-forget: extract decision/preference patterns → knowledge entries
   if (config().knowledge.enabled) {
-    for (const pat of extractPatterns(result.observations)) {
+    const patterns = extractPatterns(result.observations);
+    for (const pat of patterns) {
       try {
         ltm.create({
           projectPath: input.projectPath,
@@ -825,6 +826,9 @@ async function distillSegment(input: {
         // Dedup guard in ltm.create() handles duplicates — swallow errors
       }
     }
+    if (patterns.length > 0) {
+      log.info(`pattern extraction: ${patterns.length} entries from distillation`);
+    }
   }
 
   return result;
@@ -928,7 +932,8 @@ export async function metaDistill(input: {
 
   // Fire-and-forget: extract decision/preference patterns → knowledge entries
   if (config().knowledge.enabled) {
-    for (const pat of extractPatterns(result.observations)) {
+    const patterns = extractPatterns(result.observations);
+    for (const pat of patterns) {
       try {
         ltm.create({
           projectPath: input.projectPath,
@@ -942,6 +947,9 @@ export async function metaDistill(input: {
         // Dedup guard in ltm.create() handles duplicates — swallow errors
       }
     }
+    if (patterns.length > 0) {
+      log.info(`pattern extraction: ${patterns.length} entries from meta-distillation`);
+    }
   }
 
   return result;

package/src/embedding-vendor.ts

@@ -1,31 +1,19 @@
 /**
- * Vendored bge-small registration for the standalone Lore binary.
+ * Vendored model registration for the standalone Lore binary.
  *
- * The Bun-compiled `lore` binary uses `bun build --compile` to bundle
- * `fastembed` + `onnxruntime-node` + `@anush008/tokenizers-<platform>`
- * directly into the executable — including the platform-specific
- * `.node` addons which Bun embeds and dlopens from `$bunfs` at runtime.
+ * The Bun-compiled `lore` binary bundles `@huggingface/transformers`
+ * (which includes ONNX Runtime) into the executable. The model weights
+ * and tokenizer files (nomic-embed-text-v1.5, INT8 quantized) are
+ * embedded as Bun assets and extracted to a cache dir on first run.
  *
- * Two pieces don't fit into Bun's automatic bundling and need our help:
- *
- *  1. **Side-load shared libraries**. `onnxruntime_binding.node` does a
- *     runtime `dlopen("libonnxruntime.so.1")` (or the .dylib / .dll
- *     equivalent) for the actual ONNX Runtime computation library. Bun
- *     doesn't follow this kind of dependency. The binary's wrapper
- *     pre-loads these libs via `bun:ffi` *before* fastembed evaluates,
- *     so when the addon's dlopen fires it finds the cached handle.
- *
- *  2. **Model weights + tokenizer**. fastembed downloads from the HF
- *     Hub on first use; we want zero network on first run. The wrapper
- *     embeds the bge-small INT8 files as Bun assets, writes them to a
- *     real disk dir on first run, and sets `globalThis.__LORE_VENDOR_MODEL__`
- *     to that path. This module exposes that registration to the
- *     LocalProvider so it can hand the path to fastembed's CUSTOM-mode
- *     init (`modelAbsoluteDirPath` + `modelName`).
+ * The binary's wrapper sets `globalThis.__LORE_VENDOR_MODEL__` to the
+ * extraction path. This module exposes that registration to the
+ * `LocalProvider` so it can configure the transformers.js `env` to
+ * load from the local path instead of downloading from HuggingFace Hub.
  *
  * In npm-mode usage from `@loreai/opencode` / `@loreai/pi` the global
- * is unset and `vendorModelInfo()` returns `null`, so the LocalProvider
- * falls through to fastembed's default Qdrant repo + cache.
+ * is unset and `vendorModelInfo()` returns `null`, so transformers.js
+ * downloads the model from HF Hub on first use and caches it locally.
  */
 
 // ---------------------------------------------------------------------------
@@ -34,13 +22,10 @@
 
 /** What the binary wrapper writes to globalThis after extracting model files. */
 export interface VendorRegistration {
-  /** Absolute path to the dir containing the bge-small files
-   *  (config.json, tokenizer.json, model_quantized.onnx, …). Pass to
-   *  fastembed as `modelAbsoluteDirPath` in CUSTOM init. */
-  modelAbsoluteDirPath: string;
-  /** Filename of the ONNX weights inside that dir. Pass to fastembed
-   *  as `modelName` in CUSTOM init. */
-  modelName: string;
+  /** Absolute path to the dir containing the model files in HF layout
+   *  (config.json, tokenizer.json, onnx/model_quantized.onnx, …).
+   *  Passed to transformers.js as `env.localModelPath`. */
+  localModelPath: string;
   /** Target identifier the binary was built for, e.g. "linux-x64".
    *  Diagnostic only — the runtime doesn't branch on it. */
   target: string;
@@ -69,25 +54,23 @@ export function _setVendorRegistration(reg: VendorRegistration | null): void {
 // Public entry
 // ---------------------------------------------------------------------------
 
-/** Subset of the registration fastembed needs. Stripped of the
- *  diagnostic fields so the LocalProvider has exactly what it should
- *  hand to `FlagEmbedding.init`. */
+/** Subset of the registration the LocalProvider needs. */
 export interface VendorModelInfo {
-  modelAbsoluteDirPath: string;
-  modelName: string;
+  /** Absolute path to the dir containing the model in HF layout.
+   *  Set as `env.localModelPath` in the worker thread. */
+  localModelPath: string;
 }
 
 /**
- * Resolve the bundled-model arguments for fastembed CUSTOM init. Returns
- * `null` when no vendor is registered (npm-mode), so the caller can fall
- * through to fastembed's default cacheDir/HF Hub flow.
+ * Resolve the vendored model path for transformers.js local loading.
+ * Returns `null` when no vendor is registered (npm-mode), so the caller
+ * falls through to transformers.js's default HF Hub download + cache.
  */
 export function vendorModelInfo(): VendorModelInfo | null {
   const reg = getRegistration();
   if (!reg) return null;
   return {
-    modelAbsoluteDirPath: reg.modelAbsoluteDirPath,
-    modelName: reg.modelName,
+    localModelPath: reg.localModelPath,
   };
 }