@rohirik/openltm-core 2.9.1 → 2.11.0

package/src/cli/bin.ts

@@ -14,6 +14,7 @@
  */
 import { runInstallCli } from "./install.js";
 import { runHook } from "./hook.js";
+import { runMemoryCli } from "./memory.js";
 
 function printHelp(): void {
   process.stdout.write(
@@ -29,8 +30,10 @@ function printHelp(): void {
       "    --help, -h      Show this help",
       "",
       "  Sub-commands:",
+      "    memory <cmd>          Read/write memories from the shell (learn, recall,",
+      "                          forget, relate, context) — run 'memory --help'",
       "    hook --name <event>   Lifecycle hook stub (for Claude Code hook wiring)",
-      "    mcp-serve             Start the LTM MCP server",
+      "    mcp-serve             Start the LTM MCP server (stdio)",
       "",
       "  If no target flags are given, agents are auto-detected.",
       "",
@@ -46,6 +49,12 @@ async function main(): Promise<void> {
     process.exit(0);
   }
 
+  // Sub-command: memory (learn | recall | forget | relate | context)
+  if (argv[0] === "memory") {
+    const exitCode = await runMemoryCli(argv.slice(1));
+    process.exit(exitCode);
+  }
+
   // Sub-command: hook
   if (argv[0] === "hook") {
     const nameIdx = argv.indexOf("--name");
@@ -58,12 +67,19 @@ async function main(): Promise<void> {
     return;
   }
 
-  // Sub-command: mcp-serve (stub — full implementation deferred)
+  // Sub-command: mcp-serve — run the LTM MCP server on stdio
   if (argv[0] === "mcp-serve") {
-    process.stderr.write(
-      "  ltm mcp-serve: not yet implemented — install the Claude Code plugin for MCP server support\n",
-    );
-    process.exit(0);
+    const { startMcpServer } = await import("../mcp/server.js");
+    await startMcpServer();
+    return; // keep the process alive — transport owns the event loop
+  }
+
+  // Unknown positional sub-command: print help + exit 1. Never fall through
+  // to the install wizard (e.g. `ltm memry learn ...` must not start installing).
+  if (argv[0] && !argv[0].startsWith("--")) {
+    process.stderr.write(`  ltm: unknown sub-command '${argv[0]}'\n`);
+    printHelp();
+    process.exit(1);
   }
 
   // Parse installer flags

package/src/cli/memory.ts

@@ -0,0 +1,305 @@
+/**
+ * cli/memory.ts — `ltm memory <learn|recall|forget|relate|context>` subcommands.
+ *
+ * Gives headless/CLI agents (OpenCode CLI, scripts, cron jobs) a direct path
+ * to LTM without the agent TUI, slash commands, or a running MCP server:
+ *
+ *   bunx @rohirik/openltm-core memory learn --text "..." --category gotcha
+ *   bunx @rohirik/openltm-core memory recall --query "docker rate limit" --json
+ *
+ * DB path resolution follows paths.ts: LTM_DB_PATH > CLAUDE_PLUGIN_DATA > dev
+ * fallback. All writes route through db.ts learn() and therefore through
+ * scrubSecrets — the CLI is not a secret-leak bypass.
+ *
+ * Exit codes: 0 success · 1 usage error · 2 runtime/DB error.
+ */
+import { learn, recall, forget, relate, getContextMerge, type MemoryCategory } from "../db.js";
+import { waitForInit } from "../shared-db.js";
+
+// ── Types ─────────────────────────────────────────────────────────────────────
+
+export type MemoryCommand = "learn" | "recall" | "forget" | "relate" | "context";
+
+export interface ParsedMemoryArgs {
+  ok: true;
+  command: MemoryCommand;
+  options: Record<string, string | number | string[] | undefined>;
+  json: boolean;
+}
+
+export interface MemoryArgsError {
+  ok: false;
+  error: string;
+}
+
+export interface MemoryCommandResult {
+  exitCode: number;
+  output: string;
+}
+
+const CATEGORIES: readonly string[] = ["preference", "architecture", "gotcha", "pattern", "workflow", "constraint"];
+const RELATIONSHIP_TYPES: readonly string[] = ["supports", "contradicts", "refines", "depends_on", "related_to", "supersedes"];
+
+// ── Parsing ───────────────────────────────────────────────────────────────────
+
+/** Scan argv for `--flag value` pairs and bare `--flag` booleans. */
+function scanFlags(argv: string[]): Record<string, string | true> {
+  const flags: Record<string, string | true> = {};
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (!arg?.startsWith("--")) continue;
+    const name = arg.slice(2);
+    const next = argv[i + 1];
+    if (next !== undefined && !next.startsWith("--")) {
+      flags[name] = next;
+      i++;
+    } else {
+      flags[name] = true;
+    }
+  }
+  return flags;
+}
+
+function asInt(value: string | true | undefined): number | undefined {
+  if (typeof value !== "string") return undefined;
+  const n = Number.parseInt(value, 10);
+  return Number.isNaN(n) ? undefined : n;
+}
+
+function asList(value: string | true | undefined): string[] | undefined {
+  if (typeof value !== "string") return undefined;
+  const items = value.split(",").map((s) => s.trim()).filter(Boolean);
+  return items.length > 0 ? items : undefined;
+}
+
+/**
+ * parseMemoryArgs — pure parser for `memory` subcommand argv (without the
+ * leading "memory"). Returns a typed parse result; never exits the process.
+ */
+export function parseMemoryArgs(argv: string[]): ParsedMemoryArgs | MemoryArgsError {
+  const command = argv[0];
+  if (!command || command.startsWith("--")) {
+    return { ok: false, error: "missing subcommand — expected one of: learn, recall, forget, relate, context" };
+  }
+
+  const flags = scanFlags(argv.slice(1));
+  const json = flags["json"] === true;
+
+  switch (command) {
+    case "learn": {
+      const text = typeof flags["text"] === "string" ? flags["text"] : undefined;
+      if (!text) return { ok: false, error: "learn: --text <content> is required" };
+      const category = typeof flags["category"] === "string" ? flags["category"] : undefined;
+      if (category && !CATEGORIES.includes(category)) {
+        return { ok: false, error: `learn: invalid category '${category}' — expected one of: ${CATEGORIES.join(", ")}` };
+      }
+      const importance = asInt(flags["importance"]);
+      if (flags["importance"] !== undefined && (importance === undefined || importance < 1 || importance > 5)) {
+        return { ok: false, error: "learn: --importance must be an integer 1-5" };
+      }
+      return {
+        ok: true,
+        command: "learn",
+        json,
+        options: {
+          text,
+          title: typeof flags["title"] === "string" ? flags["title"] : undefined,
+          category,
+          importance,
+          project: typeof flags["project"] === "string" ? flags["project"] : undefined,
+          tags: asList(flags["tags"]),
+          files: asList(flags["files"]),
+        },
+      };
+    }
+
+    case "recall": {
+      const limit = asInt(flags["limit"]);
+      if (flags["limit"] !== undefined && (limit === undefined || limit < 1)) {
+        return { ok: false, error: "recall: --limit must be a positive integer" };
+      }
+      const category = typeof flags["category"] === "string" ? flags["category"] : undefined;
+      if (category && !CATEGORIES.includes(category)) {
+        return { ok: false, error: `recall: invalid category '${category}' — expected one of: ${CATEGORIES.join(", ")}` };
+      }
+      return {
+        ok: true,
+        command: "recall",
+        json,
+        options: {
+          query: typeof flags["query"] === "string" ? flags["query"] : undefined,
+          category,
+          project: typeof flags["project"] === "string" ? flags["project"] : undefined,
+          limit,
+          tags: asList(flags["tags"]),
+        },
+      };
+    }
+
+    case "forget": {
+      const id = asInt(flags["id"]);
+      if (id === undefined) return { ok: false, error: "forget: --id <number> is required" };
+      return {
+        ok: true,
+        command: "forget",
+        json,
+        options: { id, reason: typeof flags["reason"] === "string" ? flags["reason"] : undefined },
+      };
+    }
+
+    case "relate": {
+      const from = asInt(flags["from"]);
+      const to = asInt(flags["to"]);
+      const type = typeof flags["type"] === "string" ? flags["type"] : undefined;
+      if (from === undefined || to === undefined) {
+        return { ok: false, error: "relate: --from <id> and --to <id> are required" };
+      }
+      if (!type || !RELATIONSHIP_TYPES.includes(type)) {
+        return { ok: false, error: `relate: --type must be one of: ${RELATIONSHIP_TYPES.join(", ")}` };
+      }
+      return { ok: true, command: "relate", json, options: { from, to, type } };
+    }
+
+    case "context": {
+      const project = typeof flags["project"] === "string" ? flags["project"] : undefined;
+      if (!project) return { ok: false, error: "context: --project <name> is required" };
+      return { ok: true, command: "context", json, options: { project } };
+    }
+
+    default:
+      return { ok: false, error: `unknown memory subcommand '${command}' — expected one of: learn, recall, forget, relate, context` };
+  }
+}
+
+// ── Execution ─────────────────────────────────────────────────────────────────
+
+/**
+ * runMemoryCommand — execute a parsed memory command against the LTM DB.
+ * Returns output text + exit code; never writes to stdout/stderr or exits
+ * (the bin entrypoint handles I/O), so it is directly unit-testable.
+ */
+export async function runMemoryCommand(parsed: ParsedMemoryArgs): Promise<MemoryCommandResult> {
+  try {
+    await waitForInit();
+    const o = parsed.options;
+
+    switch (parsed.command) {
+      case "learn": {
+        const result = learn({
+          content: o["text"] as string,
+          title: o["title"] as string | undefined,
+          category: (o["category"] as MemoryCategory | undefined) ?? "pattern",
+          importance: o["importance"] as number | undefined,
+          project_scope: o["project"] as string | undefined,
+          tags: o["tags"] as string[] | undefined,
+          files: o["files"] as string[] | undefined,
+          actor: "cli:ltm_memory",
+        });
+        const payload = { ...result, category: (o["category"] as string | undefined) ?? "pattern" };
+        return {
+          exitCode: 0,
+          output: parsed.json
+            ? JSON.stringify(payload)
+            : `  ${payload.action === "created" ? "Stored" : "Reinforced"} memory #${payload.id} (category: ${payload.category}, confirms: ${payload.confirm_count})`,
+        };
+      }
+
+      case "recall": {
+        const results = await recall({
+          query: o["query"] as string | undefined,
+          category: o["category"] as MemoryCategory | undefined,
+          project: o["project"] as string | undefined,
+          limit: o["limit"] as number | undefined,
+          tags: o["tags"] as string[] | undefined,
+        });
+        if (parsed.json) {
+          const compact = results.map((m) => ({
+            id: m.id, title: m.title, content: m.content, category: m.category,
+            importance: m.importance, project_scope: m.project_scope,
+          }));
+          return { exitCode: 0, output: JSON.stringify(compact) };
+        }
+        if (results.length === 0) return { exitCode: 0, output: "  No memories found." };
+        const lines = results.map(
+          (m) => `  #${m.id} [${m.category}/${m.importance}]${m.project_scope ? ` (${m.project_scope})` : ""} ${m.title ?? m.content.slice(0, 60)}`,
+        );
+        return { exitCode: 0, output: lines.join("\n") };
+      }
+
+      case "forget": {
+        forget({ id: o["id"] as number, reason: o["reason"] as string | undefined, actor: "cli:ltm_memory" });
+        return {
+          exitCode: 0,
+          output: parsed.json ? JSON.stringify({ ok: true, id: o["id"] }) : `  Forgot memory #${o["id"]}`,
+        };
+      }
+
+      case "relate": {
+        relate({ source_id: o["from"] as number, target_id: o["to"] as number, relationship_type: o["type"] as string });
+        return {
+          exitCode: 0,
+          output: parsed.json ? JSON.stringify({ ok: true }) : `  Related #${o["from"]} -[${o["type"]}]-> #${o["to"]}`,
+        };
+      }
+
+      case "context": {
+        const result = getContextMerge(o["project"] as string);
+        if (parsed.json) return { exitCode: 0, output: JSON.stringify(result) };
+        const fmt = (m: { id: number; content: string }) => `  #${m.id} ${m.content.slice(0, 80)}`;
+        return {
+          exitCode: 0,
+          output: [
+            `  Globals (${result.globals.length}):`,
+            ...result.globals.map(fmt),
+            `  Scoped to ${o["project"]} (${result.scoped.length}):`,
+            ...result.scoped.map(fmt),
+          ].join("\n"),
+        };
+      }
+    }
+  } catch (err) {
+    return { exitCode: 2, output: `  ltm memory ${parsed.command}: ${String(err)}` };
+  }
+}
+
+// ── Entrypoint glue ───────────────────────────────────────────────────────────
+
+export function printMemoryHelp(): string {
+  return [
+    "",
+    "  ltm memory <command> [options]",
+    "",
+    "  Commands:",
+    "    learn    --text <content> [--title <t>] [--category <c>] [--importance 1-5]",
+    "             [--project <scope>] [--tags a,b] [--files f1,f2] [--json]",
+    "    recall   [--query <q>] [--category <c>] [--project <scope>] [--limit N]",
+    "             [--tags a,b] [--json]",
+    "    forget   --id <n> [--reason <r>] [--json]",
+    "    relate   --from <id> --to <id> --type <rel> [--json]",
+    "    context  --project <name> [--json]",
+    "",
+    `    categories: ${CATEGORIES.join(", ")}`,
+    `    relations:  ${RELATIONSHIP_TYPES.join(", ")}`,
+    "",
+    "  DB path: LTM_DB_PATH env var overrides the default plugin data location.",
+    "",
+  ].join("\n");
+}
+
+/** runMemoryCli — top-level handler invoked by bin.ts. Handles I/O + exit code. */
+export async function runMemoryCli(argv: string[]): Promise<number> {
+  if (argv[0] === "--help" || argv[0] === "-h" || argv.length === 0) {
+    process.stdout.write(printMemoryHelp());
+    return argv.length === 0 ? 1 : 0;
+  }
+  const parsed = parseMemoryArgs(argv);
+  if (!parsed.ok) {
+    process.stderr.write(`  ltm memory: ${parsed.error}\n`);
+    process.stderr.write(printMemoryHelp());
+    return 1;
+  }
+  const result = await runMemoryCommand(parsed);
+  const stream = result.exitCode === 0 ? process.stdout : process.stderr;
+  stream.write(result.output + "\n");
+  return result.exitCode;
+}

package/src/db.ts

@@ -6,6 +6,7 @@ import type { Database } from "bun:sqlite";
 import { existsSync, mkdirSync, writeFileSync } from "fs";
 import { join } from "path";
 import { normalizeKey } from "./dedup.js";
+import { normalizeAnchorPaths } from "./anchors.js";
 import { getDb, DB_PATH, configure as configureDb } from "./shared-db.js";
 import { enqueueEmbedding } from "./queue/index.js";
 import { notifyLtm, notifyMemoryAdded } from "./events/index.js";
@@ -51,6 +52,8 @@ export interface Memory {
   workspace_id?: string;
   agent_id?: string;
   decay_score?: number;
+  stale_flagged_at?: string | null;
+  stale_reason?: string | null;
 }
 
 export interface MemoryRelation {
@@ -68,6 +71,8 @@ export interface MemoryWithRelations extends Memory {
   provenance?: import("./dao/types.js").ProvenanceRow[];
   /** Score breakdown + temperature — always populated by recall(). */
   explainer?: import("./recall/explainer.js").RecallExplainer;
+  /** True when a commit touched an anchored file and the memory hasn't been re-confirmed. */
+  stale?: boolean;
 }
 
 export interface LearnInput {
@@ -83,6 +88,8 @@ export interface LearnInput {
   agent_id?: string;
   tags?: string[];
   relate_to?: Array<{ id: number; relationship_type: RelationshipType }>;
+  /** Repo-relative file paths this memory references — anchors for code-change invalidation. */
+  files?: string[];
   /** Skip regenerating docs/memory-long-term.md (use during bulk imports) */
   skipExport?: boolean;
   /** Audit/provenance — all optional; safe to omit from existing callers. */
@@ -145,6 +152,16 @@ function attachTags(db: Database, memoryId: number, tags: string[]): void {
   }
 }
 
+/** Anchor a memory to the repo files it references (merge-safe). */
+function attachFiles(db: Database, memoryId: number, files: string[], projectScope: string | null): void {
+  for (const path of normalizeAnchorPaths(files)) {
+    db.run(
+      `INSERT OR IGNORE INTO memory_files (memory_id, path, project_scope) VALUES (?, ?, ?)`,
+      [memoryId, path, projectScope],
+    );
+  }
+}
+
 /** Fetch tags for a single memory — used in recall() results. */
 function getTagsForMemory(db: Database, memoryId: number): string[] {
   return db.query<{ name: string }, [number]>(
@@ -192,7 +209,7 @@ function getRelationsForMemory(db: Database, memoryId: number): MemoryWithRelati
 }
 
 function enrichMemory(db: Database, mem: Memory): MemoryWithRelations {
-  return { ...mem, tags: getTagsForMemory(db, mem.id), relations: getRelationsForMemory(db, mem.id) };
+  return { ...mem, stale: !!mem.stale_flagged_at, tags: getTagsForMemory(db, mem.id), relations: getRelationsForMemory(db, mem.id) };
 }
 
 // --- Decay / relevance scoring ---
@@ -255,8 +272,14 @@ export function decayMemories(): DecayResult {
   ).all();
 
   const toDeprecate = rows
-    .filter(mem => mem.importance !== 5 && mem.confirm_count < 5)
-    .filter(mem => computeDecayScore(mem) < DEPRECATION_THRESHOLD)
+    .filter(mem => mem.importance !== 5)
+    .filter(mem =>
+      // Code-invalidated memories are decay-eligible regardless of recall
+      // frequency — this is the "high-traffic but stale" case decay can't
+      // otherwise see. Otherwise fall back to the recency/confirm guard.
+      mem.stale_flagged_at != null ||
+      (mem.confirm_count < 5 && computeDecayScore(mem) < DEPRECATION_THRESHOLD)
+    )
     .map(mem => mem.id);
 
   if (toDeprecate.length > 0) {
@@ -270,6 +293,92 @@ export function decayMemories(): DecayResult {
   return { deprecated: toDeprecate.length, scored: rows.length };
 }
 
+export interface FlagStaleResult {
+  flagged: number;
+  ids: number[];
+}
+
+/**
+ * Flag active memories anchored to any of `paths` as stale — the code they
+ * reference changed. Never deletes (audit trail preserved) and never touches
+ * importance=5 (permanent). Matches anchors in the same project scope or global
+ * (NULL-scoped) anchors. Idempotent: re-flagging refreshes stale_flagged_at.
+ */
+export function flagStaleByPaths(
+  paths: string[],
+  opts: { project_scope?: string | null; reason?: string; actor?: string; sessionId?: string } = {},
+): FlagStaleResult {
+  const db = getDb();
+  const norm = normalizeAnchorPaths(paths);
+  if (norm.length === 0) return { flagged: 0, ids: [] };
+
+  const scope = opts.project_scope ?? null;
+  const placeholders = norm.map(() => "?").join(",");
+  const candidates = db
+    .query<{ id: number }, (string | null)[]>(
+      `SELECT DISTINCT m.id
+         FROM memories m
+         JOIN memory_files mf ON mf.memory_id = m.id
+        WHERE m.status = 'active'
+          AND m.importance <> 5
+          AND mf.path IN (${placeholders})
+          AND (mf.project_scope IS ? OR mf.project_scope IS NULL)`,
+    )
+    .all(...norm, scope)
+    .map((r) => r.id);
+
+  const reason = opts.reason ?? "code change";
+  const actor = opts.actor ?? "git-commit";
+
+  for (const id of candidates) {
+    const beforeSnap = snapshotMemory(db, id);
+    db.run(
+      `UPDATE memories SET stale_flagged_at = datetime('now'), stale_reason = ? WHERE id = ?`,
+      [reason, id],
+    );
+    tryAudit(() => {
+      const afterSnap = snapshotMemory(db, id);
+      insertAudit(db, {
+        memory_id: id,
+        op: "update",
+        actor,
+        session_id: opts.sessionId,
+        before_json: beforeSnap ? JSON.stringify(beforeSnap) : null,
+        after_json: afterSnap ? JSON.stringify(afterSnap) : null,
+      });
+    });
+  }
+
+  return { flagged: candidates.length, ids: candidates };
+}
+
+/**
+ * Clear a stale flag — the memory was reviewed and is still valid. Use forget()
+ * instead when the memory is actually wrong. No-op if the memory wasn't flagged.
+ */
+export function revalidate(id: number): { revalidated: boolean } {
+  const db = getDb();
+  const before = snapshotMemory(db, id);
+  const res = db.run(
+    `UPDATE memories SET stale_flagged_at = NULL, stale_reason = NULL
+      WHERE id = ? AND stale_flagged_at IS NOT NULL`,
+    [id],
+  );
+  const revalidated = Number(res.changes ?? 0) > 0;
+  if (revalidated) {
+    tryAudit(() => {
+      insertAudit(db, {
+        memory_id: id,
+        op: "update",
+        actor: "revalidate",
+        before_json: before ? JSON.stringify(before) : null,
+        after_json: JSON.stringify(snapshotMemory(db, id)),
+      });
+    });
+  }
+  return { revalidated };
+}
+
 // Auto-relation detection — called fire-and-forget from learn()
 async function autoDetectRelations(
   newId: number,
@@ -322,10 +431,12 @@ export function learn(input: LearnInput): LearnResult {
     const beforeSnap = snapshotMemory(db, existing.id);
     db.run(
       `UPDATE memories SET confirm_count=confirm_count+1, last_confirmed_at=datetime('now'),
-       confidence=MIN(1.0, confidence+0.05) WHERE id=?`,
+       confidence=MIN(1.0, confidence+0.05),
+       stale_flagged_at=NULL, stale_reason=NULL WHERE id=?`,
       [existing.id]
     );
     if (input.tags) attachTags(db, existing.id, input.tags);
+    if (input.files) attachFiles(db, existing.id, input.files, existing.project_scope ?? input.project_scope ?? null);
     if (input.relate_to) {
       for (const rel of input.relate_to) {
         relate({ source_id: existing.id, target_id: rel.id, relationship_type: rel.relationship_type });
@@ -368,6 +479,7 @@ export function learn(input: LearnInput): LearnResult {
   const newId = Number(result.lastInsertRowid);
 
   if (input.tags) attachTags(db, newId, input.tags);
+  if (input.files) attachFiles(db, newId, input.files, input.project_scope ?? null);
   if (input.relate_to) {
     for (const rel of input.relate_to) {
       relate({ source_id: newId, target_id: rel.id, relationship_type: rel.relationship_type });
@@ -528,7 +640,7 @@ export async function recall(input: RecallInput = {}): Promise<MemoryWithRelatio
     `SELECT id, content, category, importance, confidence, source, project_scope, dedup_key,
             created_at, last_confirmed_at, last_used_at, confirm_count, status,
             first_recalled_at, last_recalled_at, recall_count, superseded_by, superseded_at,
-            workspace_id, agent_id, decay_score
+            workspace_id, agent_id, decay_score, stale_flagged_at, stale_reason
      FROM memories ${where} ${orderBy} LIMIT ${limit}`
   ).all(...params);
 
@@ -549,6 +661,12 @@ export async function recall(input: RecallInput = {}): Promise<MemoryWithRelatio
       .sort((a, b) => b.score - a.score)
       .map(({ m }) => m);
   }
+  // Downrank stale (code-invalidated) memories: stable partition pushes them
+  // after fresh ones at equal relevance — still returned, just demoted.
+  sorted = [
+    ...sorted.filter(m => !m.stale_flagged_at),
+    ...sorted.filter(m => m.stale_flagged_at),
+  ];
   if (sorted.length > 0) {
     const placeholders = sorted.map(() => "?").join(",");
     db.run(

package/src/index.ts

@@ -10,11 +10,11 @@ export { configureCore, configureDocs } from "./db.js";
 export {
   learn, recall, forget, relate, getSimilarMemories,
   getContextMerge, getContextMergeWithGraph, computeDecayScore,
-  exportMarkdown, exportGraphJson,
+  exportMarkdown, exportGraphJson, flagStaleByPaths, revalidate,
 } from "./db.js";
 export type {
   Memory, MemoryWithRelations, MemoryCategory, RelationshipType, MemoryRelation,
-  LearnInput, LearnResult, RecallInput, DecayResult,
+  LearnInput, LearnResult, RecallInput, DecayResult, FlagStaleResult,
 } from "./db.js";
 
 // Context items
@@ -35,6 +35,7 @@ export { listByProject, upsertGoal, appendProgress, addDecision, addGotcha } fro
 // Utilities
 export { scrubSecrets } from "./secretsScrubber.js";
 export { normalizeKey } from "./dedup.js";
+export { normalizeAnchorPath, normalizeAnchorPaths } from "./anchors.js";
 export { embedText, getLlmConfig, callLlm } from "./embeddings.js";
 
 // Recall utilities