@noir-ai/memory 1.0.0-beta.1

package/dist/index.js

@@ -0,0 +1,762 @@
+// src/capture.ts
+var CAPTURE_HOOKS = ["PreToolUse", "PostToolUse", "UserPromptSubmit", "Stop"];
+var DEFAULT_CAPTURE_HOOKS = ["Stop", "UserPromptSubmit"];
+var DEFAULT_CAPTURE_POLICY = { hooks: DEFAULT_CAPTURE_HOOKS };
+function toSaveInput(event, policy = DEFAULT_CAPTURE_POLICY) {
+  const allowed = policy.hooks ?? DEFAULT_CAPTURE_HOOKS;
+  if (!allowed.includes(event.event_type)) return null;
+  const content = buildContent(event);
+  if (content === null || content.trim().length === 0) return null;
+  const input = {
+    content,
+    type: inferType(event),
+    sessionId: event.sessionId ?? void 0
+  };
+  const files = extractFiles(event.payload);
+  if (files.length > 0) input.files = files;
+  return input;
+}
+function buildContent(event) {
+  const { event_type, payload } = event;
+  if (event_type === "Stop") {
+    return payload.summary ?? null;
+  }
+  if (event_type === "UserPromptSubmit") {
+    return payload.prompt ?? null;
+  }
+  if (typeof payload.summary === "string") return payload.summary;
+  if (typeof payload.prompt === "string") return payload.prompt;
+  return describeToolCall(payload);
+}
+function describeToolCall(payload) {
+  const { toolName, toolInput } = payload;
+  const cmd = stringField(toolInput, "command");
+  const filePath = stringField(toolInput, "file_path");
+  const pattern = stringField(toolInput, "pattern");
+  if (toolName !== void 0) {
+    if (cmd !== null) return `Ran ${toolName}: ${cmd}`;
+    if (filePath !== null) {
+      return isWriteTool(toolName) ? `Edited ${filePath}` : `${toolName}: ${filePath}`;
+    }
+    if (pattern !== null) return `${toolName} /${pattern}/`;
+    return `Used ${toolName}`;
+  }
+  if (cmd !== null) return `Ran command: ${cmd}`;
+  if (filePath !== null) return `Touched ${filePath}`;
+  return null;
+}
+function inferType(event) {
+  if (event.event_type === "UserPromptSubmit" && event.payload.prompt !== void 0) {
+    return looksDecisionShaped(event.payload.prompt) ? "decision" : "fact";
+  }
+  if (event.event_type === "PreToolUse" || event.event_type === "PostToolUse") {
+    return "workflow";
+  }
+  if (event.event_type === "Stop") {
+    return "workflow";
+  }
+  return "fact";
+}
+function extractFiles(payload) {
+  const filePath = stringField(payload.toolInput, "file_path");
+  return filePath !== null ? [filePath] : [];
+}
+function captureSource(eventType) {
+  return `auto:${String(eventType).toLowerCase()}`;
+}
+var DECISION_CUES = [
+  "decided",
+  "decision",
+  "should",
+  "let\u2019s",
+  "let's",
+  "going with",
+  "use ",
+  "adopt",
+  "convention",
+  "rule:",
+  "always ",
+  "never "
+];
+function looksDecisionShaped(prompt) {
+  const lower = prompt.toLowerCase();
+  return DECISION_CUES.some((cue) => lower.includes(cue));
+}
+function isWriteTool(toolName) {
+  const t = toolName.toLowerCase();
+  return t === "edit" || t === "write" || t === "multiedit" || t === "notebookedit";
+}
+function stringField(obj, field) {
+  if (typeof obj !== "object" || obj === null) return null;
+  const rec = obj;
+  const val = rec[field];
+  return typeof val === "string" ? val : null;
+}
+
+// src/config.ts
+function resolveMemoryConfig(raw) {
+  const cons = raw?.consolidation;
+  const enabled = cons?.enabled === true;
+  const provider = cons?.provider;
+  const model = cons?.model;
+  const types = cons?.types;
+  const consolidation = { enabled };
+  if (provider !== void 0) consolidation.provider = provider;
+  if (model !== void 0) consolidation.model = model;
+  if (types !== void 0) consolidation.types = types;
+  return { consolidation };
+}
+
+// src/consolidate.ts
+import { randomUUID } from "crypto";
+
+// src/store.ts
+var OBS_PREFIX = "memory:obs:";
+var SESSIONS_KEY = "memory:sessions";
+var INDEX_KEY = "memory:index";
+var CONSOLIDATION_MISS_KEY = "memory:consolidation:miss";
+function obsKey(id) {
+  return `${OBS_PREFIX}${id}`;
+}
+function getObservation(store, id) {
+  return store.getState(obsKey(id));
+}
+function setObservation(store, obs) {
+  store.setState(obsKey(obs.id), obs);
+}
+function clearObservation(store, id) {
+  store.setState(obsKey(id), null);
+}
+function getObservationIds(store) {
+  return store.getState(INDEX_KEY) ?? [];
+}
+function setObservationIds(store, ids) {
+  store.setState(INDEX_KEY, ids);
+}
+function getSessions(store) {
+  return store.getState(SESSIONS_KEY) ?? [];
+}
+function setSessions(store, sessions) {
+  store.setState(SESSIONS_KEY, sessions);
+}
+function bumpSession(store, sessionId, project, ts) {
+  const sessions = getSessions(store);
+  const existing = sessions.find((s) => s.id === sessionId);
+  if (existing) {
+    existing.count += 1;
+    if (ts > existing.lastTs) existing.lastTs = ts;
+  } else {
+    sessions.push({ id: sessionId, project, count: 1, lastTs: ts });
+  }
+  setSessions(store, sessions);
+}
+function decrementSession(store, sessionId) {
+  const sessions = getSessions(store);
+  const existing = sessions.find((s) => s.id === sessionId);
+  if (existing === void 0) return;
+  existing.count -= 1;
+  if (existing.count <= 0) {
+    setSessions(
+      store,
+      sessions.filter((s) => s.id !== sessionId)
+    );
+  } else {
+    setSessions(store, sessions);
+  }
+}
+function getConsolidationMisses(store) {
+  return store.getState(CONSOLIDATION_MISS_KEY) ?? [];
+}
+function appendConsolidationMiss(store, miss) {
+  const misses = getConsolidationMisses(store);
+  misses.push(miss);
+  store.setState(CONSOLIDATION_MISS_KEY, misses);
+}
+
+// src/types.ts
+var MEMORY_TYPES = [
+  "pattern",
+  "preference",
+  "architecture",
+  "bug",
+  "workflow",
+  "fact",
+  "decision",
+  "lesson"
+];
+var DEFAULT_IMPORTANCE = 0.5;
+
+// src/consolidate.ts
+var DEFAULT_CONSOLIDATE_LIMIT = 50;
+var CONSOLIDATION_SYSTEM_PROMPT = [
+  "You are consolidating a developer's cross-session memory observations.",
+  "Synthesize the given observations into ONE concise derived lesson.",
+  "State the general insight; do not merely list the inputs.",
+  "Output only the lesson text (no preamble, no JSON, no formatting)."
+].join(" ");
+async function runConsolidation(deps, opts) {
+  const { store, model, config, projectId, indexDerived } = deps;
+  const cons = config.consolidation;
+  const provider = cons?.provider;
+  if (!cons?.enabled || !provider) {
+    appendConsolidationMiss(store, { ts: Date.now(), reason: "no-provider" });
+    return { ok: false, reason: "no-provider", logged: true };
+  }
+  if (model === void 0 || !cons.model) {
+    appendConsolidationMiss(store, {
+      ts: Date.now(),
+      reason: "model-unavailable",
+      provider
+    });
+    return { ok: false, reason: "model-unavailable", logged: true };
+  }
+  const modelId = cons.model;
+  const candidates = gatherCandidates(
+    store,
+    opts?.types ?? cons.types,
+    opts?.limit ?? DEFAULT_CONSOLIDATE_LIMIT
+  );
+  if (candidates.length === 0) {
+    appendConsolidationMiss(store, {
+      ts: Date.now(),
+      reason: "no-candidates",
+      provider
+    });
+    return { ok: false, reason: "no-candidates", logged: true };
+  }
+  const result = await model.complete({
+    system: CONSOLIDATION_SYSTEM_PROMPT,
+    prompt: serializeCandidates(candidates),
+    provider,
+    model: modelId,
+    tier: "consolidate"
+  });
+  if (result === null || !result.ok) {
+    appendConsolidationMiss(store, {
+      ts: Date.now(),
+      reason: "model-unavailable",
+      provider
+    });
+    return { ok: false, reason: "model-unavailable", logged: true };
+  }
+  const text = result.text.trim();
+  if (text.length === 0) {
+    appendConsolidationMiss(store, {
+      ts: Date.now(),
+      reason: "no-candidates",
+      provider
+    });
+    return { ok: false, reason: "no-candidates", logged: true };
+  }
+  const provenance = candidates.map((c) => c.id);
+  const ts = Date.now();
+  const lesson = {
+    id: randomUUID(),
+    type: "lesson",
+    content: text,
+    project: projectId,
+    sessionId: null,
+    ts,
+    lastAccessTs: ts,
+    importance: DEFAULT_IMPORTANCE,
+    concepts: dedupeConcepts(candidates),
+    files: [],
+    source: "explicit",
+    provenance
+  };
+  await indexDerived(lesson);
+  return { ok: true, lessons: [lesson], from: provenance };
+}
+function gatherCandidates(store, types, limit) {
+  const ids = getObservationIds(store);
+  const out = [];
+  for (let i = ids.length - 1; i >= 0 && out.length < limit; i--) {
+    const id = ids[i];
+    if (id === void 0) break;
+    const obs = getObservation(store, id);
+    if (obs === null) continue;
+    if (obs.type === "lesson") continue;
+    if (types !== void 0 && !types.includes(obs.type)) continue;
+    out.push(obs);
+  }
+  return out;
+}
+function serializeCandidates(candidates) {
+  return candidates.map((c, i) => `[${i + 1}] (type: ${c.type}, ts: ${c.ts}) ${c.content}`).join("\n\n");
+}
+function dedupeConcepts(candidates) {
+  const set = /* @__PURE__ */ new Set();
+  for (const c of candidates) {
+    for (const concept of c.concepts) set.add(concept);
+  }
+  return [...set];
+}
+
+// src/engine.ts
+import { randomUUID as randomUUID2 } from "crypto";
+
+// src/recall.ts
+import { fuseRrf } from "@noir-ai/context";
+var MEMORY_SOURCE = "memory";
+var DEFAULT_RECALL_LIMIT = 10;
+var MIN_ENTITY_LEN = 3;
+var ENTITY_BOOST_PER_MATCH = 0.1;
+var STOPWORDS = /* @__PURE__ */ new Set([
+  "the",
+  "and",
+  "for",
+  "with",
+  "that",
+  "this",
+  "from",
+  "have",
+  "your",
+  "was",
+  "are",
+  "can",
+  "how",
+  "when",
+  "what",
+  "where",
+  "why",
+  "who",
+  "use",
+  "using",
+  "used",
+  "into",
+  "but",
+  "not",
+  "you",
+  "all",
+  "any",
+  "get",
+  "set",
+  "put",
+  "new",
+  "one",
+  "two",
+  "via",
+  "our",
+  "its",
+  "etc"
+]);
+function extractEntities(query) {
+  const set = /* @__PURE__ */ new Set();
+  const words = query.match(/\S+/g);
+  if (words === null) return [];
+  for (const token of words) {
+    if (/[/.:]/.test(token)) {
+      const lower = token.toLowerCase();
+      if (lower.length >= MIN_ENTITY_LEN) set.add(lower);
+    }
+    for (const piece of splitIdentifier(token)) {
+      if (piece.length < MIN_ENTITY_LEN) continue;
+      if (STOPWORDS.has(piece)) continue;
+      set.add(piece);
+    }
+  }
+  return [...set];
+}
+function splitIdentifier(token) {
+  const words = token.match(/[A-Za-z0-9]+/g);
+  if (words === null) return [];
+  const out = [];
+  for (const word of words) {
+    const spaced = word.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2");
+    for (const piece of spaced.split(/\s+/)) {
+      if (piece.length > 0) out.push(piece.toLowerCase());
+    }
+  }
+  return out;
+}
+function entityBoostForObs(obs, entities) {
+  if (entities.length === 0) return 0;
+  const contentLower = obs.content.toLowerCase();
+  let matched = 0;
+  for (const entity of entities) {
+    if (contentLower.includes(entity)) {
+      matched += 1;
+      continue;
+    }
+    if (obs.concepts.some((c) => c.toLowerCase() === entity)) {
+      matched += 1;
+      continue;
+    }
+    if (obs.files.some((f) => f.toLowerCase().includes(entity))) {
+      matched += 1;
+    }
+  }
+  return matched * ENTITY_BOOST_PER_MATCH;
+}
+async function recallMemory(deps, query, opts) {
+  const store = deps.store;
+  const limit = opts?.limit ?? DEFAULT_RECALL_LIMIT;
+  let ftsHits = [];
+  let ftsFailed = false;
+  try {
+    ftsHits = store.searchFt(query, { limit, source: MEMORY_SOURCE });
+  } catch {
+    ftsFailed = true;
+  }
+  let knnHits = [];
+  let knnFailed = false;
+  try {
+    const qvec = await deps.embed(query);
+    try {
+      knnHits = store.knn(qvec, { limit, source: MEMORY_SOURCE });
+    } catch {
+      knnFailed = true;
+    }
+  } catch {
+    knnFailed = true;
+  }
+  const mode = knnFailed ? "bm25-only" : "hybrid";
+  const degraded = knnFailed || ftsFailed;
+  const fused = fuseRrf(ftsHits, knnHits);
+  const entities = extractEntities(query);
+  const hits = [];
+  for (const row of fused) {
+    const obs = getObservation(store, row.id);
+    if (obs === null) continue;
+    if (opts?.type !== void 0 && obs.type !== opts.type) continue;
+    if (opts?.sessionId !== void 0 && obs.sessionId !== opts.sessionId) continue;
+    hits.push(toMemoryHit(obs, row.score + entityBoostForObs(obs, entities)));
+  }
+  hits.sort((a, b) => b.score - a.score);
+  return { hits: hits.slice(0, limit), degraded, mode };
+}
+function toMemoryHit(obs, score) {
+  return {
+    id: obs.id,
+    type: obs.type,
+    content: obs.content,
+    score,
+    concepts: obs.concepts,
+    files: obs.files,
+    ts: obs.ts,
+    importance: obs.importance,
+    source: obs.source
+  };
+}
+
+// src/engine.ts
+var MEMORY_SOURCE2 = "memory";
+var DEFAULT_SEARCH_LIMIT = 10;
+var DEFAULT_TYPE = "fact";
+var MemoryEngineImpl = class {
+  /** The daemon's single-writer store handle (possibly read-only). */
+  store;
+  /** Project root (stored for symmetry / future path normalization). */
+  root;
+  /** Canonical project identifier (NEVER a filesystem path — D6). */
+  projectId;
+  /**
+   * Persistent degradation flag (read-only store). Mutating ops throw a clear
+   * error upfront instead of letting the first write fail mid-run; reads
+   * (recall/search/sessions/status) keep working.
+   */
+  degraded;
+  embed;
+  model;
+  config;
+  // Single-flight serialization of ASYNC mutating ops (save / consolidate).
+  // `forget` is sync + atomic (see file header) and bypasses this chain.
+  chain = Promise.resolve();
+  constructor(opts) {
+    this.store = opts.store;
+    this.root = opts.root;
+    this.projectId = opts.projectId;
+    this.embed = opts.embed;
+    this.model = opts.model;
+    this.config = opts.config ?? {};
+    this.degraded = opts.storeDegraded === true;
+  }
+  // -------------------------------------------------------------------------
+  // save
+  // -------------------------------------------------------------------------
+  /** @inheritDoc MemoryEngine.save */
+  save(input) {
+    return this.serialized(() => this.saveInternal(input));
+  }
+  async saveInternal(input) {
+    this.assertNotDegraded("save");
+    const ts = Date.now();
+    const observation = {
+      id: randomUUID2(),
+      type: input.type ?? DEFAULT_TYPE,
+      content: input.content,
+      project: this.projectId,
+      sessionId: input.sessionId ?? null,
+      ts,
+      lastAccessTs: ts,
+      importance: input.importance ?? DEFAULT_IMPORTANCE,
+      concepts: input.concepts ?? [],
+      files: input.files ?? [],
+      source: "explicit"
+    };
+    const vec = await this.embedBestEffort(observation.content);
+    this.indexObservation(observation, vec);
+    return observation;
+  }
+  /**
+   * Write one observation to ALL three indexes in a single synchronous block:
+   * FTS5 (`indexDoc`, content searchable) + sqlite-vec (`upsertVec`, best-effort
+   * — skipped if the embedder or vec0 is unavailable, F8-style) + the
+   * authoritative KV row (`memory:obs:<id>`) + the id index + the sessions
+   * rollup. The `docs.meta` payload is the denormalized search projection
+   * (Observation minus content); the KV row is the source of truth (R4).
+   */
+  indexObservation(observation, vec) {
+    this.store.indexDoc({
+      id: observation.id,
+      source: MEMORY_SOURCE2,
+      content: observation.content,
+      meta: obsMeta(observation)
+    });
+    if (vec !== null) {
+      try {
+        this.store.upsertVec(observation.id, vec, { source: MEMORY_SOURCE2 });
+      } catch {
+      }
+    }
+    setObservation(this.store, observation);
+    const ids = getObservationIds(this.store);
+    if (!ids.includes(observation.id)) {
+      ids.push(observation.id);
+      setObservationIds(this.store, ids);
+    }
+    if (observation.sessionId !== null) {
+      bumpSession(this.store, observation.sessionId, observation.project, observation.ts);
+    }
+  }
+  // -------------------------------------------------------------------------
+  // get (extra public method — hydrate the FULL row from KV, DS-9)
+  // -------------------------------------------------------------------------
+  /**
+   * Hydrate the full {@link Observation} for `id` from the authoritative KV row.
+   * Returns `null` for an unknown / forgotten id. This is the only correct way
+   * to read an observation's complete `content` (DS-9).
+   */
+  get(id) {
+    return getObservation(this.store, id);
+  }
+  // -------------------------------------------------------------------------
+  // recall (t3: hybrid BM25 ∪ kNN + RRF + entity-boost — see recall.ts)
+  // -------------------------------------------------------------------------
+  /** @inheritDoc MemoryEngine.recall */
+  async recall(query, opts) {
+    const { hits } = await recallMemory({ store: this.store, embed: this.embed }, query, opts);
+    return hits;
+  }
+  // -------------------------------------------------------------------------
+  // search (BM25-only instant path — final design, DS-7)
+  // -------------------------------------------------------------------------
+  /** @inheritDoc MemoryEngine.search */
+  async search(query, opts) {
+    const limit = opts?.limit ?? DEFAULT_SEARCH_LIMIT;
+    let ftsHits = [];
+    try {
+      ftsHits = this.store.searchFt(query, { source: MEMORY_SOURCE2, limit });
+    } catch {
+      return [];
+    }
+    return this.hydrateHits(
+      ftsHits.map((h) => ({ id: h.id, score: h.score })),
+      void 0
+    );
+  }
+  /**
+   * Hydrate a ranked id list into {@link MemoryHit}s from the authoritative KV
+   * row, applying the optional `type` / `sessionId` filters. Each hit carries
+   * the FULL `content` (DS-9). A ranked id with no KV row (a stale vec-only hit
+   * whose row was forgotten) is dropped — never emitted with partial data.
+   */
+  hydrateHits(scored, opts) {
+    const out = [];
+    for (const row of scored) {
+      const obs = getObservation(this.store, row.id);
+      if (obs === null) continue;
+      if (opts?.type !== void 0 && obs.type !== opts.type) continue;
+      if (opts?.sessionId !== void 0 && obs.sessionId !== opts.sessionId) continue;
+      out.push(toMemoryHit2(obs, row.score));
+    }
+    return out;
+  }
+  // -------------------------------------------------------------------------
+  // sessions
+  // -------------------------------------------------------------------------
+  /** @inheritDoc MemoryEngine.sessions */
+  sessions() {
+    return getSessions(this.store);
+  }
+  // -------------------------------------------------------------------------
+  // forget (synchronous + atomic — see file header)
+  // -------------------------------------------------------------------------
+  /** @inheritDoc MemoryEngine.forget */
+  forget(ids) {
+    this.assertNotDegraded("forget");
+    let deleted = 0;
+    const idSet = new Set(ids);
+    for (const id of ids) {
+      const obs = getObservation(this.store, id);
+      if (obs === null) continue;
+      this.store.deleteDoc(id);
+      try {
+        this.store.deleteVec(id);
+      } catch {
+      }
+      clearObservation(this.store, id);
+      if (obs.sessionId !== null) {
+        decrementSession(this.store, obs.sessionId);
+      }
+      deleted += 1;
+    }
+    if (deleted > 0) {
+      const remaining = getObservationIds(this.store).filter((i) => !idSet.has(i));
+      setObservationIds(this.store, remaining);
+    }
+    return { deleted, ids };
+  }
+  // -------------------------------------------------------------------------
+  // consolidate (explicit, provider-gated — DS-6)
+  // -------------------------------------------------------------------------
+  /** @inheritDoc MemoryEngine.consolidate */
+  consolidate(opts) {
+    return this.serialized(() => this.consolidateInternal(opts));
+  }
+  async consolidateInternal(opts) {
+    return runConsolidation(
+      {
+        store: this.store,
+        model: this.model,
+        config: this.config,
+        projectId: this.projectId,
+        indexDerived: async (obs) => {
+          const vec = await this.embedBestEffort(obs.content);
+          this.indexObservation(obs, vec);
+        }
+      },
+      opts
+    );
+  }
+  // -------------------------------------------------------------------------
+  // status
+  // -------------------------------------------------------------------------
+  /** @inheritDoc MemoryEngine.status */
+  status() {
+    return {
+      ok: true,
+      projectId: this.store.projectId,
+      observations: getObservationIds(this.store).length,
+      degraded: this.degraded
+    };
+  }
+  // -------------------------------------------------------------------------
+  // shared internals
+  // -------------------------------------------------------------------------
+  /**
+   * Best-effort embedding: returns the vec, or `null` if the embedder is
+   * unavailable (`kind:'none'`, native load failure, provider error). A `null`
+   * vec skips `upsertVec` so the save still succeeds — the row is BM25-searchable
+   * + hydrated from KV (F8-style degradation).
+   */
+  async embedBestEffort(content) {
+    try {
+      return await this.embed(content);
+    } catch {
+      return null;
+    }
+  }
+  /** Throw a clear, typed error when the store handle is read-only. */
+  assertNotDegraded(op) {
+    if (this.degraded) {
+      throw new Error(`memory ${op} refused: store is read-only (daemon down)`);
+    }
+  }
+  /**
+   * Single-flight serialization of async mutating ops (mirrors the context
+   * indexer's `serialized`). Forces `work` to run strictly after the previous
+   * queued op completes. A failed op does NOT poison the queue — the chain
+   * advances regardless, and the caller observes the real outcome via `result`.
+   */
+  serialized(work) {
+    const result = this.chain.then(work);
+    this.chain = result.then(
+      () => void 0,
+      () => void 0
+    );
+    return result;
+  }
+};
+function createMemoryEngine(opts) {
+  return new MemoryEngineImpl(opts);
+}
+function obsMeta(obs) {
+  const meta = {
+    type: obs.type,
+    project: obs.project,
+    sessionId: obs.sessionId,
+    ts: obs.ts,
+    lastAccessTs: obs.lastAccessTs,
+    importance: obs.importance,
+    concepts: obs.concepts,
+    files: obs.files,
+    source: obs.source
+  };
+  if (obs.provenance !== void 0) meta.provenance = obs.provenance;
+  return meta;
+}
+function toMemoryHit2(obs, score) {
+  return {
+    id: obs.id,
+    type: obs.type,
+    content: obs.content,
+    score,
+    concepts: obs.concepts,
+    files: obs.files,
+    ts: obs.ts,
+    importance: obs.importance,
+    source: obs.source
+  };
+}
+export {
+  CAPTURE_HOOKS,
+  CONSOLIDATION_MISS_KEY,
+  CONSOLIDATION_SYSTEM_PROMPT,
+  DEFAULT_CAPTURE_HOOKS,
+  DEFAULT_CAPTURE_POLICY,
+  DEFAULT_CONSOLIDATE_LIMIT,
+  DEFAULT_IMPORTANCE,
+  INDEX_KEY,
+  MEMORY_TYPES,
+  MemoryEngineImpl,
+  OBS_PREFIX,
+  SESSIONS_KEY,
+  appendConsolidationMiss,
+  buildContent,
+  bumpSession,
+  captureSource,
+  clearObservation,
+  createMemoryEngine,
+  decrementSession,
+  dedupeConcepts,
+  describeToolCall,
+  extractEntities,
+  extractFiles,
+  gatherCandidates,
+  getConsolidationMisses,
+  getObservation,
+  getObservationIds,
+  getSessions,
+  inferType,
+  obsKey,
+  recallMemory,
+  resolveMemoryConfig,
+  runConsolidation,
+  serializeCandidates,
+  setObservation,
+  setObservationIds,
+  setSessions,
+  toSaveInput
+};
+//# sourceMappingURL=index.js.map