@theokit/sdk-memory 0.1.0

package/dist/index.cjs

@@ -0,0 +1,2585 @@
+'use strict';
+
+var promises = require('fs/promises');
+var path = require('path');
+var sdk = require('@theokit/sdk');
+var persistence = require('@theokit/sdk/internal/persistence');
+var pathSafety = require('@theokit/sdk/path-safety');
+var crypto = require('crypto');
+var errors = require('@theokit/sdk/errors');
+var fs = require('fs');
+var module$1 = require('module');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+// src/in-memory-provider.ts
+var ADAPTER_ID = "in-memory-md";
+var INTERNAL_STATE = /* @__PURE__ */ Symbol("sdk-memory.in-memory.state");
+function buildCapabilities() {
+  return {
+    history: false,
+    sessions: false,
+    tenancy: false,
+    reasoning: false,
+    toolSchemas: false,
+    prefetch: false
+  };
+}
+function buildAdapter(state) {
+  return {
+    id: ADAPTER_ID,
+    capabilities: buildCapabilities(),
+    isAvailable() {
+      return true;
+    },
+    async write(content, _ctx) {
+      const text = typeof content === "string" ? content : content.map((m) => m.content).join("\n");
+      const safeText = sdk.Security.redact(text);
+      const id = `${ADAPTER_ID}:${state.counter.next++}`;
+      state.facts.set(id, {
+        id,
+        content: safeText,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      return id;
+    },
+    async recall(_query, _ctx, k) {
+      const all = Array.from(state.facts.values());
+      const limit = k !== void 0 && k >= 0 ? k : all.length;
+      return all.slice(0, limit);
+    },
+    async delete(id) {
+      if (!String(id).startsWith(`${ADAPTER_ID}:`)) {
+        throw new Error(
+          `MemoryAdapter.delete: id "${String(id)}" was not minted by adapter "${ADAPTER_ID}"`
+        );
+      }
+      state.facts.delete(id);
+    }
+  };
+}
+var MAX_SUMMARY_TURN_CHARS = 2e3;
+function truncate(text) {
+  if (text.length <= MAX_SUMMARY_TURN_CHARS) return text;
+  return `${text.slice(0, MAX_SUMMARY_TURN_CHARS)}\u2026`;
+}
+function sanitizeRunId(runId) {
+  return runId.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 128);
+}
+function renderSessionSummaryMarkdown(args) {
+  const iso = new Date(args.at).toISOString();
+  const safeUser = sdk.Security.redact(truncate(args.userText));
+  const safeAssistant = sdk.Security.redact(truncate(args.assistantText));
+  return [
+    "---",
+    `runId: ${args.runId}`,
+    `agentId: ${args.agentId}`,
+    `at: ${iso}`,
+    `status: ${args.status}`,
+    "---",
+    "",
+    "## User",
+    "",
+    safeUser,
+    "",
+    "## Assistant",
+    "",
+    safeAssistant,
+    ""
+  ].join("\n");
+}
+function extractAgentIdFromFrontmatter(content) {
+  const match = content.match(/^agentId:\s*(.+)$/m);
+  if (match === null || match[1] === void 0) return void 0;
+  return match[1].trim();
+}
+async function recallSessionSummaries(cwd, userMessage, agentIdFilter) {
+  const RECALL_CAP = 5;
+  const sessionsDir2 = path.join(cwd, ".theokit", "memory", "sessions");
+  let files;
+  try {
+    files = await promises.readdir(sessionsDir2);
+  } catch {
+    return [];
+  }
+  const query = userMessage.toLowerCase().trim();
+  if (query.length === 0) return [];
+  const hits = [];
+  for (const file of files) {
+    if (!file.endsWith(".md")) continue;
+    if (hits.length >= RECALL_CAP) break;
+    const filePath = path.join(sessionsDir2, file);
+    let content;
+    try {
+      content = await promises.readFile(filePath, "utf-8");
+    } catch {
+      continue;
+    }
+    if (agentIdFilter !== void 0) {
+      const fileAgentId = extractAgentIdFromFrontmatter(content);
+      if (fileAgentId !== agentIdFilter) continue;
+    }
+    if (content.toLowerCase().includes(query)) {
+      const userIdx = content.indexOf("## User");
+      const snippet = userIdx >= 0 ? content.slice(userIdx, userIdx + 200).replace(/\s+/g, " ") : file;
+      const id = `${ADAPTER_ID}:session:${file}`;
+      hits.push({
+        id,
+        content: snippet,
+        score: 0.5
+        // substring-match has no real score; placeholder
+      });
+    }
+  }
+  return hits;
+}
+function buildMemorySearchTool(state) {
+  return {
+    name: "memory_search",
+    description: "Search past session summaries for content related to a query. Use when the user asks about something they mentioned in a previous conversation. Returns up to 5 short snippets.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "What to search for (a topic, fact, or keyword)."
+        }
+      },
+      required: ["query"],
+      additionalProperties: false
+    },
+    handler: async (input) => {
+      const query = typeof input.query === "string" ? input.query : "";
+      if (query.length === 0) {
+        return JSON.stringify({ ok: false, results: [], error: "empty query" });
+      }
+      const hits = await recallSessionSummaries(state.cwd, query);
+      return JSON.stringify({
+        ok: true,
+        count: hits.length,
+        results: hits.map((h) => ({ id: String(h.id), snippet: h.content }))
+      });
+    }
+  };
+}
+function buildMemoryRememberTool(state) {
+  return {
+    name: "memory_remember",
+    description: "Persist a short fact about the user/conversation to memory so it can be recalled in future turns. Pass a single concise sentence as `content`.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        content: { type: "string", description: "The fact to remember (one sentence)." }
+      },
+      required: ["content"],
+      additionalProperties: false
+    },
+    handler: async (input) => {
+      const content = typeof input.content === "string" ? input.content : "";
+      if (content.length === 0) {
+        return JSON.stringify({ ok: false, error: "empty content" });
+      }
+      const safeContent = sdk.Security.redact(content);
+      const id = `${ADAPTER_ID}:${state.counter.next++}`;
+      state.facts.set(id, {
+        id,
+        content: safeContent,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      return JSON.stringify({ ok: true, id });
+    }
+  };
+}
+function createInMemoryMarkdownProvider() {
+  return {
+    async init(opts) {
+      const state = {
+        facts: /* @__PURE__ */ new Map(),
+        counter: { next: 0 },
+        cwd: opts.cwd
+      };
+      const adapter = buildAdapter(state);
+      return {
+        adapter,
+        [INTERNAL_STATE]: state
+      };
+    },
+    buildTools(handle, _agent) {
+      const state = handle[INTERNAL_STATE];
+      if (state === void 0) return [];
+      return [buildMemoryRememberTool(state), buildMemorySearchTool(state)];
+    },
+    async runActivePass(handle, args) {
+      const state = handle[INTERNAL_STATE];
+      if (state === void 0) return { facts: [] };
+      const inProcessFacts = Array.from(state.facts.values());
+      const persistedHits = await recallSessionSummaries(state.cwd, args.userMessage, args.agentId);
+      const allFacts = [...inProcessFacts, ...persistedHits];
+      if (allFacts.length === 0) return { facts: [] };
+      const systemPromptAdditions = [
+        "Known facts about the user/session (recall):",
+        ...allFacts.map((f) => `- ${f.content}`)
+      ].join("\n");
+      return { facts: allFacts, systemPromptAdditions };
+    },
+    sync(_handle) {
+      return;
+    },
+    async recordSessionSummary(args) {
+      if (args.status !== "finished") return;
+      const sessionsPath = path.join(args.cwd, ".theokit", "memory", "sessions");
+      const filePath = path.join(sessionsPath, `${sanitizeRunId(args.runId)}.md`);
+      await promises.mkdir(sessionsPath, { recursive: true });
+      const body = renderSessionSummaryMarkdown(args);
+      await persistence.replaceFileAtomic(filePath, body);
+    },
+    dispose(handle) {
+      const state = handle[INTERNAL_STATE];
+      if (state === void 0) return;
+      state.facts.clear();
+    }
+  };
+}
+function redactSecrets(text, opts) {
+  return sdk.Security.redact(text, opts);
+}
+function legacyMemoryJsonPath(cwd, config) {
+  if (config.storePath !== void 0) {
+    return path.resolve(cwd, config.storePath);
+  }
+  const namespace = pathSafety.sanitizeIdentifier(config.namespace ?? "default");
+  const scope = pathSafety.sanitizeIdentifier(config.scope ?? "agent", { maxLen: 16 });
+  const userId = pathSafety.sanitizeIdentifier(config.userId ?? "default");
+  return pathSafety.safePathJoin(cwd, ".theokit", "memory", namespace, `${scope}-${userId}.json`);
+}
+
+// src/internal/markdown-store.ts
+var MEMORY_MD_HEADER = "# Memory\n\n> Auto-managed by @theokit/sdk. Edit freely \u2014 the SDK reads from here.\n";
+var FACTS_HEADING = "## Facts";
+function memoryDir(cwd) {
+  return path.join(cwd, ".theokit", "memory");
+}
+function memoryMdPath(cwd) {
+  return path.join(memoryDir(cwd), "MEMORY.md");
+}
+function notesDir(cwd) {
+  return path.join(memoryDir(cwd), "notes");
+}
+async function readFactsFromMarkdown(cwd) {
+  let raw;
+  try {
+    raw = await promises.readFile(memoryMdPath(cwd), "utf8");
+  } catch {
+    return [];
+  }
+  return parseFactsSection(raw);
+}
+function appendFactToMarkdown(cwd, fact) {
+  return persistence.withCwdMutex(memoryDir(cwd), async () => {
+    const path = memoryMdPath(cwd);
+    let raw = "";
+    try {
+      raw = await promises.readFile(path, "utf8");
+    } catch {
+      raw = "";
+    }
+    const sanitized = redactSecrets(fact.text);
+    const next = insertFactBullet(raw, sanitized);
+    await promises.mkdir(memoryDir(cwd), { recursive: true });
+    await persistence.replaceFileAtomic(path, next);
+  });
+}
+async function listNotes(cwd) {
+  let entries = [];
+  try {
+    entries = await promises.readdir(notesDir(cwd));
+  } catch {
+    return [];
+  }
+  return entries.filter((name) => name.endsWith(".md")).map((name) => ({ slug: name.replace(/\.md$/, ""), path: path.join(notesDir(cwd), name) }));
+}
+function parseFactsSection(raw) {
+  const idx = raw.indexOf(FACTS_HEADING);
+  if (idx === -1) return [];
+  const tail = raw.slice(idx + FACTS_HEADING.length);
+  const nextHeading = tail.search(/\n#{1,2}\s/);
+  const block = nextHeading === -1 ? tail : tail.slice(0, nextHeading);
+  return block.split("\n").map((line) => line.trim()).filter((line) => line.startsWith("- ")).map((line) => ({ text: line.slice(2).trim() }));
+}
+function insertFactBullet(raw, fact) {
+  const bullet = `- ${fact}`;
+  if (raw.length === 0) {
+    return `${MEMORY_MD_HEADER}
+${FACTS_HEADING}
+
+${bullet}
+`;
+  }
+  const idx = raw.indexOf(FACTS_HEADING);
+  if (idx === -1) {
+    const sep = raw.endsWith("\n") ? "" : "\n";
+    return `${raw}${sep}
+${FACTS_HEADING}
+
+${bullet}
+`;
+  }
+  const after = idx + FACTS_HEADING.length;
+  const nextHeading = raw.slice(after).search(/\n#{1,2}\s/);
+  if (nextHeading === -1) {
+    const trailing = raw.endsWith("\n") ? "" : "\n";
+    return `${raw}${trailing}${bullet}
+`;
+  }
+  const insertAt = after + nextHeading;
+  return `${raw.slice(0, insertAt)}
+${bullet}${raw.slice(insertAt)}`;
+}
+async function readFacts(cwd, config) {
+  if (!config.enabled) return [];
+  return readFactsFromMarkdown(cwd);
+}
+async function appendFact(cwd, config, fact) {
+  if (!config.enabled) return;
+  await appendFactToMarkdown(cwd, fact);
+}
+
+// src/internal/transcript-store.ts
+async function persistActiveMemoryTranscript(cwd, transcript) {
+  try {
+    const dir = path.join(memoryDir(cwd), "transcripts", "active-memory");
+    const file = path.join(dir, `${transcript.runId}.json`);
+    await persistence.atomicWriteJson(file, transcript);
+  } catch (cause) {
+    const message = cause instanceof Error ? cause.message : String(cause);
+    process.stderr.write(`[theokit-sdk] active-memory transcript persist failed: ${message}
+`);
+  }
+}
+
+// src/internal/active-memory.ts
+var SPAN_MEMORY_RECALL = "memory.recall";
+var HISTOGRAM_MEMORY_RECALL_DURATION_MS = "theokit_memory_recall_duration_ms";
+var DEFAULTS = {
+  queryMode: "recent",
+  timeoutMs: 15e3,
+  maxSummaryChars: 220,
+  recentUserTurns: 2
+};
+async function runActiveMemory(args) {
+  const started = Date.now();
+  const span = startMemoryRecallSpan(args);
+  try {
+    if (args.options.enabled !== true || args.index === void 0) {
+      return endRecallSpan(span, args, {
+        summary: void 0,
+        durationMs: 0,
+        status: "skipped",
+        hits: []
+      });
+    }
+    const cfg = { ...DEFAULTS, ...args.options };
+    const breakerKey = args.agentKey ?? "default";
+    if (args.breaker?.shouldSkip(breakerKey) === true) {
+      return endRecallSpan(span, args, {
+        summary: void 0,
+        durationMs: 0,
+        status: "skipped",
+        hits: []
+      });
+    }
+    const cached = args.cache?.get(args.userText, cfg.queryMode);
+    if (cached !== void 0) return endRecallSpan(span, args, cached);
+    const query = buildQuery(args.userText, args.priorMessages, cfg.queryMode, cfg.recentUserTurns);
+    if (query.trim().length === 0) {
+      const finalized2 = await finalize(args, cfg.queryMode, {
+        summary: void 0,
+        durationMs: Date.now() - started,
+        status: "no-recall",
+        hits: []
+      });
+      return endRecallSpan(span, args, finalized2);
+    }
+    const result = await searchOnce(args, cfg, query, started);
+    notifyBreaker(args.breaker, breakerKey, result.status);
+    const finalized = await finalize(args, cfg.queryMode, result);
+    return endRecallSpan(span, args, finalized);
+  } catch (cause) {
+    span.recordException(cause);
+    span.setStatus({ code: 2, message: cause instanceof Error ? cause.message : String(cause) });
+    span.end();
+    throw cause;
+  }
+}
+function startMemoryRecallSpan(args) {
+  const telemetry = args.telemetry;
+  if (telemetry === void 0) {
+    return {
+      setAttribute: () => {
+      },
+      setAttributes: () => {
+      },
+      addEvent: () => {
+      },
+      setStatus: () => {
+      },
+      recordException: () => {
+      },
+      end: () => {
+      },
+      spanContext: () => ({ traceId: "0".repeat(32), spanId: "0".repeat(16) }),
+      isRecording: () => false
+    };
+  }
+  return telemetry.startSpan(SPAN_MEMORY_RECALL, {
+    queryMode: args.options.queryMode ?? "recent",
+    ...args.userId !== void 0 ? { userId: args.userId } : {},
+    ...args.namespace !== void 0 ? { namespace: args.namespace } : {},
+    ...args.scope !== void 0 ? { scope: args.scope } : {}
+  });
+}
+function endRecallSpan(span, args, result) {
+  span.setAttributes({
+    hits: result.hits.length,
+    status: result.status,
+    durationMs: result.durationMs
+  });
+  span.end();
+  args.telemetry?.recordHistogram(HISTOGRAM_MEMORY_RECALL_DURATION_MS, result.durationMs, {
+    status: result.status,
+    ...args.userId !== void 0 ? { userId: args.userId } : {},
+    ...args.namespace !== void 0 ? { namespace: args.namespace } : {},
+    ...args.scope !== void 0 ? { scope: args.scope } : {}
+  });
+  return result;
+}
+async function searchOnce(args, cfg, query, started) {
+  if (args.index === void 0) {
+    return { summary: void 0, durationMs: 0, status: "skipped", hits: [] };
+  }
+  try {
+    const hits = await withTimeout(args.index.search(query, { maxResults: 5 }), cfg.timeoutMs);
+    if (hits === "timeout") {
+      return { summary: void 0, durationMs: Date.now() - started, status: "timeout", hits: [] };
+    }
+    if (hits.length === 0) {
+      return {
+        summary: void 0,
+        durationMs: Date.now() - started,
+        status: "no-recall",
+        hits: []
+      };
+    }
+    const summary = formatSummary(hits, cfg.maxSummaryChars);
+    return { summary, durationMs: Date.now() - started, status: "ok", hits };
+  } catch (cause) {
+    const message = cause instanceof Error ? cause.message : String(cause);
+    process.stderr.write(`[theokit-sdk] active-memory recall failed: ${message}
+`);
+    return { summary: void 0, durationMs: Date.now() - started, status: "error", hits: [] };
+  }
+}
+function notifyBreaker(breaker, key, status) {
+  if (breaker === void 0) return;
+  if (status === "timeout") breaker.recordTimeout(key);
+  else if (status === "ok" || status === "no-recall") breaker.recordSuccess(key);
+}
+async function finalize(args, queryMode, result) {
+  args.cache?.set(args.userText, queryMode, result);
+  if (args.persistTranscripts === true && args.cwd !== void 0) {
+    await persistActiveMemoryTranscript(args.cwd, {
+      runId: args.runId ?? `run-${Date.now()}`,
+      startedAtMs: Date.now() - result.durationMs,
+      userText: args.userText,
+      queryMode,
+      status: result.status,
+      durationMs: result.durationMs,
+      summary: result.summary,
+      hits: result.hits.map((h) => ({
+        path: h.path,
+        startLine: h.startLine,
+        endLine: h.endLine,
+        score: h.score,
+        snippet: h.snippet
+      }))
+    });
+  }
+  return result;
+}
+function buildQuery(userText, priorMessages, queryMode, recentUserTurns) {
+  if (queryMode === "message") return userText;
+  if (queryMode === "full") {
+    const allUserTurns = priorMessages.filter((m) => m.role === "user").map((m) => m.text);
+    return [...allUserTurns, userText].join("\n");
+  }
+  const recent = priorMessages.filter((m) => m.role === "user").slice(-recentUserTurns).map((m) => m.text);
+  return [...recent, userText].join("\n");
+}
+function formatSummary(hits, maxChars) {
+  const lines = hits.map((h) => `- ${h.citation}: ${h.snippet}`);
+  let summary = lines.join("\n");
+  if (summary.length > maxChars) summary = `${summary.slice(0, maxChars - 1)}\u2026`;
+  return summary;
+}
+async function withTimeout(promise, timeoutMs) {
+  let timer;
+  const timeout = new Promise((resolve) => {
+    timer = setTimeout(() => resolve("timeout"), timeoutMs);
+  });
+  try {
+    const winner = await Promise.race([promise, timeout]);
+    return winner;
+  } finally {
+    if (timer !== void 0) clearTimeout(timer);
+  }
+}
+
+// src/internal/circuit-breaker.ts
+var DEFAULT_MAX_TIMEOUTS = 3;
+var DEFAULT_COOLDOWN_MS = 6e4;
+var CircuitBreaker = class {
+  constructor(opts = {}) {
+    this.opts = opts;
+  }
+  opts;
+  states = /* @__PURE__ */ new Map();
+  /** @returns true when the breaker is open and the call should be skipped. */
+  shouldSkip(key) {
+    const state = this.states.get(key);
+    if (state === void 0) return false;
+    if (state.cooldownUntilMs === 0) return false;
+    if (this.now() < state.cooldownUntilMs) return true;
+    state.cooldownUntilMs = 0;
+    state.consecutiveTimeouts = 0;
+    return false;
+  }
+  recordSuccess(key) {
+    const state = this.states.get(key);
+    if (state === void 0) return;
+    state.consecutiveTimeouts = 0;
+    state.cooldownUntilMs = 0;
+  }
+  recordTimeout(key) {
+    const state = this.states.get(key) ?? { consecutiveTimeouts: 0, cooldownUntilMs: 0 };
+    state.consecutiveTimeouts += 1;
+    if (state.consecutiveTimeouts >= (this.opts.maxTimeouts ?? DEFAULT_MAX_TIMEOUTS)) {
+      state.cooldownUntilMs = this.now() + (this.opts.cooldownMs ?? DEFAULT_COOLDOWN_MS);
+    }
+    this.states.set(key, state);
+  }
+  /** @internal — tests inspect counter state. */
+  inspect(key) {
+    return this.states.get(key) ?? { consecutiveTimeouts: 0, cooldownUntilMs: 0 };
+  }
+  now() {
+    return this.opts.now?.() ?? Date.now();
+  }
+};
+var DEFAULT_TTL_MS = 15e3;
+var DEFAULT_CAPACITY = 1e3;
+var ActiveMemoryCache = class {
+  constructor(opts = {}) {
+    this.opts = opts;
+  }
+  opts;
+  map = /* @__PURE__ */ new Map();
+  get(userText, queryMode, tenantCtx) {
+    const key = cacheKey(userText, queryMode, tenantCtx);
+    const entry = this.map.get(key);
+    if (entry === void 0) return void 0;
+    if (this.now() >= entry.expiresAtMs) {
+      this.map.delete(key);
+      return void 0;
+    }
+    this.map.delete(key);
+    this.map.set(key, entry);
+    return entry.result;
+  }
+  set(userText, queryMode, result, tenantCtx) {
+    const key = cacheKey(userText, queryMode, tenantCtx);
+    if (this.map.size >= (this.opts.capacity ?? DEFAULT_CAPACITY)) {
+      const oldest = this.map.keys().next().value;
+      if (oldest !== void 0) this.map.delete(oldest);
+    }
+    this.map.set(key, {
+      expiresAtMs: this.now() + (this.opts.ttlMs ?? DEFAULT_TTL_MS),
+      result
+    });
+  }
+  size() {
+    return this.map.size;
+  }
+  now() {
+    return this.opts.now?.() ?? Date.now();
+  }
+};
+function cacheKey(userText, queryMode, ctx) {
+  const parts = [queryMode, ctx?.namespace ?? "", ctx?.userId ?? "", ctx?.scope ?? "", userText];
+  return crypto.createHash("sha256").update(parts.join("\0")).digest("hex");
+}
+var RAW_MAX_BYTES = 2048;
+function parseRetryAfter(headers) {
+  if (headers === void 0) return void 0;
+  const raw = headers.get("retry-after");
+  if (raw === null) return void 0;
+  const n = Number(raw);
+  if (Number.isFinite(n) && n >= 0) return Math.ceil(n);
+  return void 0;
+}
+function truncateRaw(body) {
+  if (body === null || body === void 0) return void 0;
+  const s = typeof body === "string" ? body : JSON.stringify(body);
+  const truncated = s.length <= RAW_MAX_BYTES ? s : `${s.slice(0, RAW_MAX_BYTES)}\u2026`;
+  return redactSecrets(truncated);
+}
+function buildErrorMetadata(args) {
+  const retryAfter = parseRetryAfter(args.headers);
+  const raw = truncateRaw(args.body);
+  return {
+    provider: args.provider,
+    endpoint: args.endpoint,
+    code: args.code,
+    statusCode: args.status,
+    ...retryAfter !== void 0 ? { retryAfter } : {},
+    ...raw !== void 0 ? { raw } : {}
+  };
+}
+function mapOpenAICompatibleError(args) {
+  const { providerId, status, body, headers, endpoint } = args;
+  const code = mapOpenAiStatusToCode(status, body);
+  const message = formatMessage(providerId, status, code);
+  const metadata = buildErrorMetadata({
+    provider: providerId,
+    endpoint,
+    code,
+    status,
+    headers,
+    body
+  });
+  if (status === 401 || status === 403) {
+    return new errors.AuthenticationError(message, { code: `${providerId}_auth_failed`, metadata });
+  }
+  if (status === 429) {
+    return new errors.RateLimitError(message, { code: `${providerId}_rate_limit`, metadata });
+  }
+  if (status === 400) {
+    return new errors.ConfigurationError(message, { code: `${providerId}_${code}`, metadata });
+  }
+  if (status === 408) {
+    return new errors.NetworkError(message, { code: `${providerId}_timeout`, metadata });
+  }
+  if (status >= 500 && status < 600) {
+    return new errors.NetworkError(message, { code: `${providerId}_server_error`, metadata });
+  }
+  return new errors.UnknownAgentError(message, { code: `${providerId}_unknown`, metadata });
+}
+function extractOpenAiErrorCode(body) {
+  if (body === null || typeof body !== "object") return void 0;
+  const err = body.error;
+  if (err === void 0 || err === null) return void 0;
+  if (typeof err.code === "string") return err.code;
+  if (typeof err.type === "string") return err.type;
+  return void 0;
+}
+function mapOpenAiStatusToCode(status, body) {
+  const rawCode = extractOpenAiErrorCode(body)?.toLowerCase() ?? "";
+  if (rawCode.includes("context_length") || rawCode.includes("context_window") || rawCode.includes("too_many_tokens") || rawCode.includes("max_tokens")) {
+    return "context_too_long";
+  }
+  if (rawCode.includes("content_filter") || rawCode.includes("content_policy") || rawCode.includes("safety")) {
+    return "content_filtered";
+  }
+  if (rawCode.includes("model_not_found") || rawCode.includes("model_unavailable") || rawCode.includes("invalid_model")) {
+    return "model_unavailable";
+  }
+  if (status === 402 || rawCode.includes("insufficient_quota") || rawCode.includes("quota_exceeded")) {
+    return "quota_exceeded";
+  }
+  if (status === 401 || status === 403) return "auth_failed";
+  if (status === 429) return "rate_limit";
+  if (status === 408) return "timeout";
+  if (status === 400) return "invalid_request";
+  if (status >= 500 && status < 600) return "server_error";
+  return "unknown";
+}
+function formatMessage(providerId, status, code) {
+  return `${providerId} API error: ${code} (HTTP ${status})`;
+}
+
+// src/internal/embedding-cache.ts
+var LruEmbeddingCache = class {
+  constructor(capacity = 5e3) {
+    this.capacity = capacity;
+  }
+  capacity;
+  map = /* @__PURE__ */ new Map();
+  get(key) {
+    const value = this.map.get(key);
+    if (value === void 0) return void 0;
+    this.map.delete(key);
+    this.map.set(key, value);
+    return value;
+  }
+  set(key, value) {
+    if (this.map.has(key)) this.map.delete(key);
+    else if (this.map.size >= this.capacity) {
+      const oldest = this.map.keys().next().value;
+      if (oldest !== void 0) this.map.delete(oldest);
+    }
+    this.map.set(key, value);
+  }
+  size() {
+    return this.map.size;
+  }
+};
+
+// src/internal/openai-compatible.ts
+var MAX_BATCH = 100;
+var MAX_RETRIES = 2;
+async function createOpenAiCompatibleRuntime(cfg, options) {
+  const model = options.model ?? cfg.defaultModel;
+  const apiKey = options.apiKey ?? process.env[cfg.apiKeyEnv];
+  if (apiKey === void 0 || apiKey.length === 0) {
+    throw new errors.AuthenticationError(`${cfg.apiKeyEnv} missing`, {
+      code: "embedding_missing_api_key"
+    });
+  }
+  const envBaseUrl = cfg.baseUrlEnv !== void 0 ? process.env[cfg.baseUrlEnv] : void 0;
+  const baseUrl = options.baseUrl ?? envBaseUrl ?? cfg.defaultBaseUrl;
+  const fetchImpl = options.fetch ?? fetch;
+  const cache = options.cache ?? new LruEmbeddingCache();
+  const dimension = cfg.dimensionByModel[model];
+  if (dimension === void 0) {
+    throw new errors.ConfigurationError(
+      `${cfg.id} adapter: model "${model}" is not in the dimension table. Use one of: ${Object.keys(cfg.dimensionByModel).join(", ")}. To add it, update dimensionByModel in the adapter source.`,
+      { code: "embedding_unknown_model" }
+    );
+  }
+  const embeddingsPath = cfg.embeddingsPath ?? "/v1/embeddings";
+  const stats = {
+    cacheHits: 0,
+    cacheMisses: 0,
+    httpCalls: 0,
+    retries: 0
+  };
+  return {
+    id: cfg.id,
+    model,
+    dimension,
+    stats: () => ({ ...stats }),
+    embed: (texts) => embedTexts({
+      texts,
+      cache,
+      stats,
+      model,
+      dimension,
+      apiKey,
+      baseUrl,
+      embeddingsPath,
+      fetchImpl,
+      providerId: cfg.id
+    })
+  };
+}
+async function embedTexts(input) {
+  const { texts, cache, stats, model, dimension } = input;
+  const results = new Array(texts.length);
+  const pending = [];
+  for (let i = 0; i < texts.length; i++) {
+    classifyEntry({
+      index: i,
+      text: texts[i] ?? "",
+      model,
+      dimension,
+      cache,
+      stats,
+      results,
+      pending
+    });
+  }
+  await runBatches(input, pending, results);
+  return results.map((v) => v ?? new Array(dimension).fill(0));
+}
+function classifyEntry(args) {
+  if (args.text.trim().length === 0) {
+    args.results[args.index] = new Array(args.dimension).fill(0);
+    return;
+  }
+  const key = hashKey(args.model, args.text);
+  const cached = args.cache.get(key);
+  if (cached !== void 0) {
+    args.stats.cacheHits += 1;
+    args.results[args.index] = cached;
+    return;
+  }
+  args.stats.cacheMisses += 1;
+  args.pending.push({ index: args.index, text: args.text, key });
+}
+async function runBatches(input, pending, results) {
+  for (let offset = 0; offset < pending.length; offset += MAX_BATCH) {
+    const batch = pending.slice(offset, offset + MAX_BATCH);
+    const vectors = await embedBatch({
+      apiKey: input.apiKey,
+      baseUrl: input.baseUrl,
+      embeddingsPath: input.embeddingsPath,
+      model: input.model,
+      inputs: batch.map((b) => b.text),
+      fetchImpl: input.fetchImpl,
+      stats: input.stats,
+      providerId: input.providerId
+    });
+    for (let j = 0; j < batch.length; j++) {
+      const slot = batch[j];
+      const vector = vectors[j];
+      if (slot === void 0 || vector === void 0) continue;
+      results[slot.index] = vector;
+      input.cache.set(slot.key, vector);
+    }
+  }
+}
+async function embedBatch(opts) {
+  const url = `${opts.baseUrl.replace(/\/$/, "")}${opts.embeddingsPath}`;
+  let attempt = 0;
+  while (true) {
+    opts.stats.httpCalls += 1;
+    const response = await postEmbedRequest(opts, url);
+    if (response.ok)
+      return await parseEmbedResponse(response, opts.providerId, opts.embeddingsPath);
+    if (isRetryable(response.status) && attempt < MAX_RETRIES) {
+      attempt += 1;
+      opts.stats.retries += 1;
+      await sleep(linearBackoffMs(attempt));
+      continue;
+    }
+    const text = await response.text().catch(() => "");
+    let body = text;
+    try {
+      body = JSON.parse(text);
+    } catch {
+    }
+    throw mapOpenAICompatibleError({
+      providerId: opts.providerId,
+      status: response.status,
+      body,
+      headers: response.headers,
+      endpoint: opts.embeddingsPath
+    });
+  }
+}
+async function postEmbedRequest(opts, url) {
+  return opts.fetchImpl(url, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      authorization: `Bearer ${opts.apiKey}`
+    },
+    body: JSON.stringify({ model: opts.model, input: opts.inputs })
+  });
+}
+async function parseEmbedResponse(response, providerId, endpoint) {
+  const json = await response.json();
+  if (!Array.isArray(json.data)) {
+    throw new errors.NetworkError(`${providerId} ${endpoint} returned no data`, {
+      code: "embedding_invalid_response",
+      metadata: {
+        provider: providerId,
+        endpoint,
+        code: "invalid_request",
+        raw: json
+      }
+    });
+  }
+  return json.data.map((d) => d.embedding);
+}
+function isRetryable(status) {
+  return status === 429 || status >= 500 && status < 600;
+}
+function hashKey(model, text) {
+  return crypto.createHash("sha256").update(`${model} ${text}`).digest("hex");
+}
+function linearBackoffMs(attempt) {
+  return 50 * attempt;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/internal/deepinfra-embedding.ts
+var DEFAULT_DEEPINFRA_EMBEDDING_MODEL = "BAAI/bge-large-en-v1.5";
+var DIMENSION_BY_MODEL = {
+  "BAAI/bge-large-en-v1.5": 1024,
+  "BAAI/bge-base-en-v1.5": 768,
+  "BAAI/bge-small-en-v1.5": 384,
+  "BAAI/bge-m3": 1024,
+  "intfloat/e5-large-v2": 1024,
+  "intfloat/e5-base-v2": 768,
+  "intfloat/multilingual-e5-large": 1024,
+  "sentence-transformers/all-MiniLM-L6-v2": 384,
+  "thenlper/gte-large": 1024,
+  "thenlper/gte-base": 768
+};
+var deepinfraMemoryEmbeddingProviderAdapter = {
+  id: "deepinfra",
+  defaultModel: DEFAULT_DEEPINFRA_EMBEDDING_MODEL,
+  transport: "remote",
+  authProviderId: "deepinfra",
+  autoSelectPriority: 13,
+  create: (options) => createOpenAiCompatibleRuntime(
+    {
+      id: "deepinfra",
+      defaultBaseUrl: "https://api.deepinfra.com",
+      apiKeyEnv: "DEEPINFRA_API_KEY",
+      baseUrlEnv: "DEEPINFRA_API_BASE_URL",
+      defaultModel: DEFAULT_DEEPINFRA_EMBEDDING_MODEL,
+      dimensionByModel: DIMENSION_BY_MODEL,
+      embeddingsPath: "/v1/openai/embeddings"
+    },
+    options
+  )
+};
+
+// src/internal/mistral-embedding.ts
+var DEFAULT_MISTRAL_EMBEDDING_MODEL = "mistral-embed";
+var DIMENSION_BY_MODEL2 = {
+  "mistral-embed": 1024
+};
+var mistralMemoryEmbeddingProviderAdapter = {
+  id: "mistral",
+  defaultModel: DEFAULT_MISTRAL_EMBEDDING_MODEL,
+  transport: "remote",
+  authProviderId: "mistral",
+  autoSelectPriority: 18,
+  create: (options) => createOpenAiCompatibleRuntime(
+    {
+      id: "mistral",
+      defaultBaseUrl: "https://api.mistral.ai",
+      apiKeyEnv: "MISTRAL_API_KEY",
+      baseUrlEnv: "MISTRAL_API_BASE_URL",
+      defaultModel: DEFAULT_MISTRAL_EMBEDDING_MODEL,
+      dimensionByModel: DIMENSION_BY_MODEL2
+    },
+    options
+  )
+};
+
+// src/internal/ollama-embedding.ts
+var DEFAULT_OLLAMA_EMBEDDING_MODEL = "nomic-embed-text";
+var OLLAMA_LOCAL_SENTINEL_KEY = "ollama-local";
+var DIMENSION_BY_MODEL3 = {
+  // Nomic — local default, recommended quality/size balance.
+  "nomic-embed-text": 768,
+  "nomic-embed-text:latest": 768,
+  // Sentence-transformers MiniLM — smaller, faster, lower quality.
+  "all-minilm": 384,
+  "all-minilm:latest": 384,
+  // BGE family.
+  "bge-large": 1024,
+  "bge-large:latest": 1024,
+  "bge-m3": 1024,
+  "bge-m3:latest": 1024,
+  // mxbai-embed-large.
+  "mxbai-embed-large": 1024,
+  "mxbai-embed-large:latest": 1024
+};
+var ollamaMemoryEmbeddingProviderAdapter = {
+  id: "ollama",
+  defaultModel: DEFAULT_OLLAMA_EMBEDDING_MODEL,
+  transport: "local",
+  authProviderId: "ollama",
+  // Lower than remote providers — chosen only when explicitly requested
+  // OR when no remote provider key is configured (local-first developer).
+  autoSelectPriority: 10,
+  create: (options) => {
+    const apiKey = options.apiKey ?? process.env.OLLAMA_API_KEY ?? OLLAMA_LOCAL_SENTINEL_KEY;
+    return createOpenAiCompatibleRuntime(
+      {
+        id: "ollama",
+        defaultBaseUrl: "http://localhost:11434",
+        apiKeyEnv: "OLLAMA_API_KEY",
+        baseUrlEnv: "OLLAMA_HOST",
+        defaultModel: DEFAULT_OLLAMA_EMBEDDING_MODEL,
+        dimensionByModel: DIMENSION_BY_MODEL3
+      },
+      { ...options, apiKey }
+    );
+  }
+};
+
+// src/internal/openai-embedding.ts
+var DEFAULT_OPENAI_EMBEDDING_MODEL = "text-embedding-3-small";
+var DIMENSION_BY_MODEL4 = {
+  "text-embedding-3-small": 1536,
+  "text-embedding-3-large": 3072,
+  "text-embedding-ada-002": 1536
+};
+var openAiMemoryEmbeddingProviderAdapter = {
+  id: "openai",
+  defaultModel: DEFAULT_OPENAI_EMBEDDING_MODEL,
+  transport: "remote",
+  authProviderId: "openai",
+  autoSelectPriority: 20,
+  create: (options) => createOpenAiCompatibleRuntime(
+    {
+      id: "openai",
+      defaultBaseUrl: "https://api.openai.com",
+      apiKeyEnv: "OPENAI_API_KEY",
+      baseUrlEnv: "OPENAI_API_BASE_URL",
+      defaultModel: DEFAULT_OPENAI_EMBEDDING_MODEL,
+      dimensionByModel: DIMENSION_BY_MODEL4
+    },
+    options
+  )
+};
+
+// src/internal/openrouter-embedding.ts
+var DEFAULT_OPENROUTER_EMBEDDING_MODEL = "openai/text-embedding-3-small";
+var DIMENSION_BY_MODEL5 = {
+  "openai/text-embedding-3-small": 1536,
+  "openai/text-embedding-3-large": 3072,
+  "openai/text-embedding-ada-002": 1536,
+  "mistralai/mistral-embed": 1024
+};
+var openRouterMemoryEmbeddingProviderAdapter = {
+  id: "openrouter",
+  defaultModel: DEFAULT_OPENROUTER_EMBEDDING_MODEL,
+  transport: "remote",
+  authProviderId: "openrouter",
+  autoSelectPriority: 15,
+  create: (options) => createOpenAiCompatibleRuntime(
+    {
+      id: "openrouter",
+      defaultBaseUrl: "https://openrouter.ai/api",
+      apiKeyEnv: "OPENROUTER_API_KEY",
+      baseUrlEnv: "OPENROUTER_API_BASE_URL",
+      defaultModel: DEFAULT_OPENROUTER_EMBEDDING_MODEL,
+      dimensionByModel: DIMENSION_BY_MODEL5
+    },
+    options
+  )
+};
+
+// src/internal/voyage-embedding.ts
+var DEFAULT_VOYAGE_EMBEDDING_MODEL = "voyage-3-lite";
+var DIMENSION_BY_MODEL6 = {
+  "voyage-3-lite": 512,
+  "voyage-3": 1024,
+  "voyage-3-large": 1024,
+  "voyage-code-3": 1024,
+  "voyage-multilingual-2": 1024
+};
+var voyageMemoryEmbeddingProviderAdapter = {
+  id: "voyage",
+  defaultModel: DEFAULT_VOYAGE_EMBEDDING_MODEL,
+  transport: "remote",
+  authProviderId: "voyage",
+  autoSelectPriority: 14,
+  create: (options) => createOpenAiCompatibleRuntime(
+    {
+      id: "voyage",
+      defaultBaseUrl: "https://api.voyageai.com",
+      apiKeyEnv: "VOYAGE_API_KEY",
+      baseUrlEnv: "VOYAGE_API_BASE_URL",
+      defaultModel: DEFAULT_VOYAGE_EMBEDDING_MODEL,
+      dimensionByModel: DIMENSION_BY_MODEL6
+    },
+    options
+  )
+};
+
+// src/internal/adapter-catalog.ts
+var MEMORY_EMBEDDING_ADAPTERS = {
+  openai: openAiMemoryEmbeddingProviderAdapter,
+  mistral: mistralMemoryEmbeddingProviderAdapter,
+  openrouter: openRouterMemoryEmbeddingProviderAdapter,
+  voyage: voyageMemoryEmbeddingProviderAdapter,
+  deepinfra: deepinfraMemoryEmbeddingProviderAdapter,
+  ollama: ollamaMemoryEmbeddingProviderAdapter
+};
+var HEADING_RE = /^(#{1,6})\s+(.+?)\s*$/;
+function chunkMarkdown(text, options = {}) {
+  const maxChars = options.maxChars ?? 800;
+  if (text.length === 0) return [];
+  const lines = text.split("\n");
+  const acc = { chunks: [], lines: [], start: 1, heading: void 0 };
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    const lineNumber = i + 1;
+    processLine(acc, line, lineNumber, maxChars);
+  }
+  flushAccumulator(acc, lines.length, maxChars);
+  return acc.chunks;
+}
+function processLine(acc, line, lineNumber, maxChars) {
+  const headingMatch = HEADING_RE.exec(line);
+  const isBlank = line.trim().length === 0;
+  if (headingMatch !== null && acc.lines.length > 0) {
+    flushAccumulator(acc, lineNumber - 1, maxChars);
+  }
+  if (headingMatch !== null) acc.heading = headingMatch[2];
+  acc.lines.push(line);
+  if (isBlank && acc.lines.length > 1) {
+    const joined = acc.lines.join("\n");
+    if (joined.trim().length > 0) flushAccumulator(acc, lineNumber, maxChars);
+  }
+}
+function flushAccumulator(acc, endLineExclusive, maxChars) {
+  if (acc.lines.length === 0) return;
+  const chunkText = acc.lines.join("\n");
+  if (chunkText.trim().length === 0) {
+    acc.lines = [];
+    acc.start = endLineExclusive + 1;
+    return;
+  }
+  if (chunkText.length > maxChars) {
+    pushOversizedSlices(acc.chunks, chunkText, acc.start, acc.heading, maxChars);
+  } else {
+    acc.chunks.push(buildChunk(chunkText, acc.start, endLineExclusive, acc.heading));
+  }
+  acc.lines = [];
+  acc.start = endLineExclusive + 1;
+}
+function buildChunk(text, startLine, endLine, heading) {
+  return {
+    startLine,
+    endLine,
+    text,
+    hash: crypto.createHash("sha256").update(text).digest("hex"),
+    ...heading !== void 0 ? { heading } : {}
+  };
+}
+function pushOversizedSlices(chunks, text, startLine, heading, maxChars) {
+  let remaining = text;
+  let lineCursor = startLine;
+  while (remaining.length > maxChars) {
+    const splitAt = findWordBoundarySplit(remaining, maxChars);
+    const slice = remaining.slice(0, splitAt);
+    const sliceLines = slice.split("\n").length;
+    chunks.push(buildChunk(slice, lineCursor, lineCursor + sliceLines - 1, heading));
+    remaining = remaining.slice(splitAt).replace(/^\s+/, "");
+    lineCursor += sliceLines - 1;
+  }
+  if (remaining.length > 0) {
+    const sliceLines = remaining.split("\n").length;
+    chunks.push(buildChunk(remaining, lineCursor, lineCursor + sliceLines - 1, heading));
+  }
+}
+function findWordBoundarySplit(text, maxChars) {
+  if (text.length <= maxChars) return text.length;
+  for (let i = maxChars; i > Math.max(0, maxChars - 200); i--) {
+    if (/\s/.test(text[i] ?? "x")) return i;
+  }
+  return maxChars;
+}
+function diaryPath(cwd) {
+  return path.join(memoryDir(cwd), "dream-diary.md");
+}
+function renderDiaryEntry(entry) {
+  const stamp = new Date(entry.timestampMs).toISOString();
+  const hash = entryHash(entry).slice(0, 8);
+  return [
+    `## ${stamp}`,
+    "",
+    `- entry-hash: ${hash}`,
+    `- facts before: ${entry.factsBefore}`,
+    `- facts after: ${entry.factsAfter}`,
+    `- duplicates removed: ${entry.duplicatesRemoved}`,
+    `- clusters created: ${entry.clustersCreated}`,
+    `- notes written: ${entry.notesWritten}`,
+    ""
+  ].join("\n");
+}
+async function appendDiaryEntry(cwd, entry) {
+  const path = diaryPath(cwd);
+  let raw = "";
+  try {
+    raw = await promises.readFile(path, "utf8");
+  } catch {
+    raw = "# Dream Diary\n\n";
+  }
+  const next = `${raw.endsWith("\n") ? raw : `${raw}
+`}${renderDiaryEntry(entry)}`;
+  await persistence.replaceFileAtomic(path, next);
+}
+function entryHash(entry) {
+  return crypto.createHash("sha256").update(
+    [
+      entry.factsBefore,
+      entry.factsAfter,
+      entry.duplicatesRemoved,
+      entry.clustersCreated,
+      entry.notesWritten
+    ].join("|")
+  ).digest("hex");
+}
+
+// src/internal/dreaming-phases.ts
+var DEFAULT_DEDUP_THRESHOLD = 0.95;
+var DEFAULT_CLUSTER_THRESHOLD = 0.75;
+async function lightPhase(facts, embedding, threshold = DEFAULT_DEDUP_THRESHOLD) {
+  if (facts.length <= 1) return { kept: [...facts], duplicatesRemoved: 0 };
+  const vectors = await embedding.embed(facts.map((f) => f.text));
+  const keptIdx = [];
+  const keptVecs = [];
+  for (let i = 0; i < facts.length; i++) {
+    const vec = vectors[i] ?? [];
+    const isDup = keptVecs.some((kept2) => cosineSimilarity(vec, kept2) >= threshold);
+    if (isDup) continue;
+    keptIdx.push(i);
+    keptVecs.push(vec);
+  }
+  const kept = keptIdx.map((i) => facts[i]);
+  return { kept, duplicatesRemoved: facts.length - kept.length };
+}
+var DEFAULT_MAX_FACTS_PER_SWEEP = 500;
+async function remPhase(facts, embedding, threshold = DEFAULT_CLUSTER_THRESHOLD, maxFactsPerSweep = DEFAULT_MAX_FACTS_PER_SWEEP) {
+  if (facts.length === 0) return { clusters: [] };
+  const capped = facts.length > maxFactsPerSweep ? facts.slice(0, maxFactsPerSweep) : facts;
+  const vectors = await embedding.embed(capped.map((f) => f.text));
+  const clusterOfIdx = unionFindByPairs(vectors, threshold);
+  const groups = bucketFactsByClusterRoot(capped, clusterOfIdx);
+  return { clusters: [...groups.values()].map(buildClusterFromMembers) };
+}
+function unionFindByPairs(vectors, threshold) {
+  const clusterOfIdx = vectors.map((_, i) => i);
+  for (let i = 0; i < vectors.length; i++) {
+    for (let j = i + 1; j < vectors.length; j++) {
+      if (cosineSimilarity(vectors[i] ?? [], vectors[j] ?? []) >= threshold) {
+        unifyClusters(clusterOfIdx, i, j);
+      }
+    }
+  }
+  return clusterOfIdx;
+}
+function bucketFactsByClusterRoot(facts, clusterOfIdx) {
+  const groups = /* @__PURE__ */ new Map();
+  for (let i = 0; i < facts.length; i++) {
+    const root = findRoot(clusterOfIdx, i);
+    const list = groups.get(root) ?? [];
+    list.push(facts[i]);
+    groups.set(root, list);
+  }
+  return groups;
+}
+function buildClusterFromMembers(members) {
+  const sorted = [...members].sort((a, b) => b.text.length - a.text.length);
+  return { representativeText: sorted[0]?.text ?? "", members };
+}
+function deepPhase(clusters, timestampMs) {
+  if (clusters.length === 0) return "";
+  const isoStamp = new Date(timestampMs).toISOString();
+  const lines = [`# Dreamed ${isoStamp}`, ""];
+  for (let i = 0; i < clusters.length; i++) {
+    const c = clusters[i];
+    if (c === void 0) continue;
+    lines.push(`## Cluster ${i + 1}: ${c.representativeText}`);
+    lines.push("");
+    for (const member of c.members) lines.push(`- ${member.text}`);
+    lines.push("");
+  }
+  return `${lines.join("\n")}
+`;
+}
+function cosineSimilarity(a, b) {
+  if (a.length === 0 || b.length === 0 || a.length !== b.length) return 0;
+  let dot = 0;
+  let aNorm = 0;
+  let bNorm = 0;
+  for (let i = 0; i < a.length; i++) {
+    const ai = a[i] ?? 0;
+    const bi = b[i] ?? 0;
+    dot += ai * bi;
+    aNorm += ai * ai;
+    bNorm += bi * bi;
+  }
+  const denom = Math.sqrt(aNorm) * Math.sqrt(bNorm);
+  return denom === 0 ? 0 : dot / denom;
+}
+function findRoot(parents, i) {
+  let root = i;
+  while (parents[root] !== root) {
+    const next = parents[root] ?? root;
+    if (next === root) break;
+    root = next;
+  }
+  parents[i] = root;
+  return root;
+}
+function unifyClusters(parents, a, b) {
+  const rootA = findRoot(parents, a);
+  const rootB = findRoot(parents, b);
+  if (rootA !== rootB) parents[rootB] = rootA;
+}
+function runDreamingSweep(options) {
+  return persistence.withCwdMutex(`dream:${options.cwd}`, () => runInner(options));
+}
+async function runInner(options) {
+  const now = options.now ?? Date.now;
+  const timestampMs = now();
+  try {
+    const facts = await readFactsFromMarkdown(options.cwd);
+    if (facts.length === 0) {
+      return emptyResult("skipped");
+    }
+    const dedup = await lightPhase(facts, options.embedding, options.dedupThreshold);
+    const rem = await remPhase(dedup.kept, options.embedding, options.clusterThreshold);
+    const notesWritten = await writeConsolidatedNotes(options.cwd, rem.clusters, timestampMs);
+    const result = {
+      status: "ok",
+      factsBefore: facts.length,
+      factsAfter: dedup.kept.length,
+      duplicatesRemoved: dedup.duplicatesRemoved,
+      clustersCreated: rem.clusters.length,
+      notesWritten,
+      diaryEntryHash: void 0
+    };
+    await appendDiaryEntry(options.cwd, {
+      timestampMs,
+      factsBefore: result.factsBefore,
+      factsAfter: result.factsAfter,
+      duplicatesRemoved: result.duplicatesRemoved,
+      clustersCreated: result.clustersCreated,
+      notesWritten: result.notesWritten
+    });
+    return result;
+  } catch (cause) {
+    const message = cause instanceof Error ? cause.message : String(cause);
+    process.stderr.write(`[theokit-sdk] dreaming sweep failed: ${message}
+`);
+    return emptyResult("error");
+  }
+}
+async function writeConsolidatedNotes(cwd, clusters, timestampMs) {
+  if (clusters.length === 0) return 0;
+  const notesDir2 = path.join(memoryDir(cwd), "notes");
+  await promises.mkdir(notesDir2, { recursive: true });
+  const isoSlug = new Date(timestampMs).toISOString().replace(/[^\dT]/g, "-");
+  const file = path.join(notesDir2, `dreamed-${isoSlug}.md`);
+  const body = deepPhase(clusters, timestampMs);
+  await persistence.replaceFileAtomic(file, body);
+  return 1;
+}
+function emptyResult(status) {
+  return {
+    status,
+    factsBefore: 0,
+    factsAfter: 0,
+    duplicatesRemoved: 0,
+    clustersCreated: 0,
+    notesWritten: 0,
+    diaryEntryHash: void 0
+  };
+}
+
+// src/internal/index-schema.ts
+var SCHEMA_STATEMENTS = [
+  `CREATE TABLE IF NOT EXISTS files (
+     id INTEGER PRIMARY KEY AUTOINCREMENT,
+     path TEXT UNIQUE NOT NULL,
+     rel_path TEXT NOT NULL,
+     mtime INTEGER NOT NULL,
+     hash TEXT NOT NULL,
+     source TEXT NOT NULL DEFAULT 'memory'
+   )`,
+  `CREATE TABLE IF NOT EXISTS chunks (
+     id INTEGER PRIMARY KEY AUTOINCREMENT,
+     file_id INTEGER NOT NULL REFERENCES files(id) ON DELETE CASCADE,
+     start_line INTEGER NOT NULL,
+     end_line INTEGER NOT NULL,
+     text TEXT NOT NULL,
+     hash TEXT NOT NULL,
+     session_key TEXT
+   )`,
+  `CREATE VIRTUAL TABLE IF NOT EXISTS chunks_fts USING fts5(
+     text,
+     content='chunks',
+     content_rowid='id'
+   )`,
+  `CREATE TRIGGER IF NOT EXISTS chunks_fts_insert AFTER INSERT ON chunks BEGIN
+     INSERT INTO chunks_fts(rowid, text) VALUES (new.id, new.text);
+   END`,
+  `CREATE TRIGGER IF NOT EXISTS chunks_fts_delete AFTER DELETE ON chunks BEGIN
+     INSERT INTO chunks_fts(chunks_fts, rowid, text) VALUES ('delete', old.id, old.text);
+   END`,
+  `CREATE TABLE IF NOT EXISTS meta (
+     key TEXT PRIMARY KEY,
+     value TEXT
+   )`,
+  `CREATE INDEX IF NOT EXISTS idx_chunks_file_id ON chunks(file_id)`
+];
+var MIGRATION_V2_STATEMENTS = [
+  "ALTER TABLE chunks ADD COLUMN created_at INTEGER",
+  "ALTER TABLE chunks ADD COLUMN importance REAL DEFAULT 0.5",
+  "ALTER TABLE chunks ADD COLUMN scope TEXT DEFAULT '/'"
+];
+var PRAGMA_STATEMENTS = [
+  "PRAGMA synchronous=NORMAL",
+  "PRAGMA foreign_keys=ON"
+];
+
+// src/internal/index-db.ts
+async function openMemoryDb(opts) {
+  await promises.mkdir(path.dirname(opts.filePath), { recursive: true });
+  try {
+    return await openConcrete(opts.filePath);
+  } catch (cause) {
+    if (opts.recoverCorrupt !== false && isCorruptionError(cause)) {
+      await renameAside(opts.filePath);
+      return await openConcrete(opts.filePath);
+    }
+    throw cause;
+  }
+}
+async function openConcrete(filePath) {
+  const db = await loadDriver(filePath);
+  persistence.applyWalWithFallback(db, "memory-index");
+  for (const pragma of PRAGMA_STATEMENTS) db.exec(pragma);
+  for (const stmt of SCHEMA_STATEMENTS) db.exec(stmt);
+  return db;
+}
+async function loadDriver(filePath) {
+  try {
+    const mod = await import('better-sqlite3');
+    const Ctor = mod.default ?? mod;
+    const db = new Ctor(filePath);
+    return db;
+  } catch (cause) {
+    const message = cause instanceof Error ? cause.message : String(cause);
+    throw new errors.ConfigurationError(
+      `Failed to load SQLite driver. Install \`better-sqlite3\` or run on Node 22.5+ for built-in \`node:sqlite\`. Cause: ${message}`,
+      { code: "sqlite_driver_unavailable", cause }
+    );
+  }
+}
+function isCorruptionError(cause) {
+  if (!(cause instanceof Error)) return false;
+  const msg = cause.message.toLowerCase();
+  return msg.includes("malformed") || msg.includes("not a database") || msg.includes("encrypted") || msg.includes("disk image is malformed");
+}
+async function renameAside(filePath) {
+  const asidePath = `${filePath}.corrupt-${Date.now()}`;
+  await promises.rename(filePath, asidePath).catch(() => void 0);
+  await promises.rename(`${filePath}-wal`, `${asidePath}-wal`).catch(() => void 0);
+  await promises.rename(`${filePath}-shm`, `${asidePath}-shm`).catch(() => void 0);
+  process.stderr.write(
+    `[theokit-sdk] memory index corrupt; renamed aside to ${asidePath} and rebuilt schema
+`
+  );
+}
+function defaultIndexPath(cwd) {
+  return path.join(cwd, ".theokit", "memory", ".index", "memory.sqlite");
+}
+function requireLance() {
+  try {
+    const r = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
+    return r("@lancedb/lancedb");
+  } catch (cause) {
+    throw new errors.ConfigurationError(
+      'Lance backend selected but `@lancedb/lancedb` is not installed. Install with: `pnpm add @lancedb/lancedb`. SQLite remains available as the default (omit `backend: "lance"`).',
+      { code: "lance_backend_unavailable", cause }
+    );
+  }
+}
+var LanceIndex = class _LanceIndex {
+  constructor(table, embedding, embeddingDim) {
+    this.table = table;
+    this.embedding = embedding;
+    this.embeddingDim = embeddingDim;
+  }
+  table;
+  embedding;
+  embeddingDim;
+  static async open(opts) {
+    const lance = requireLance();
+    const storagePath = opts.storagePath ?? path.join(opts.cwd, ".theokit", "memory", "lance");
+    fs.mkdirSync(storagePath, { recursive: true });
+    const conn = await lance.connect(storagePath);
+    const dim = opts.embedding.dimension;
+    const tableName = "facts";
+    const existing = await conn.tableNames();
+    let table;
+    if (existing.includes(tableName)) {
+      table = await conn.openTable(tableName);
+      const schema = await table.schema();
+      const embField = schema.fields.find((f) => f.name === "embedding");
+      const existingDim = embField?.type?.listSize ?? embField?.type?.fixedSize;
+      if (typeof existingDim === "number" && existingDim !== dim) {
+        throw new errors.ConfigurationError(
+          `Embedding dimension mismatch in Lance index: storage has ${existingDim}-dim vectors, current provider yields ${dim}-dim. Run \`theokit-migrate-memory\` after switching providers, or use a different storagePath.`,
+          { code: "embedding_dimension_mismatch" }
+        );
+      }
+    } else {
+      const bootstrap = {
+        id: "__bootstrap__",
+        text: "",
+        source: "memory",
+        embedding: new Array(dim).fill(0),
+        namespace: "__bootstrap__",
+        scope: "__bootstrap__",
+        user_id: "__bootstrap__",
+        timestamp: 0
+      };
+      table = await conn.createTable(tableName, [bootstrap]);
+      await table.delete("namespace = '__bootstrap__'");
+    }
+    return new _LanceIndex(table, opts.embedding, dim);
+  }
+  async addFacts(facts) {
+    if (facts.length === 0) return;
+    const texts = facts.map((f) => f.text);
+    const embeddings = await this.embedding.embed(texts);
+    const rows = facts.map((f, i) => ({
+      ...f,
+      embedding: embeddings[i] ?? new Array(this.embeddingDim).fill(0)
+    }));
+    await this.table.add(rows);
+  }
+  /**
+   * Search facts by semantic similarity. EC-1: filters use Lance's
+   * SQL string predicate with `'` → `''` escape — bind parameters are
+   * not supported by Lance 0.30.
+   */
+  async search(query, opts) {
+    const [embedding] = await this.embedding.embed([query]);
+    if (embedding === void 0) return [];
+    const predicates = [`namespace = '${escapeSqlValue(opts.namespace)}'`];
+    if (opts.scope !== void 0) {
+      predicates.push(`scope = '${escapeSqlValue(opts.scope)}'`);
+    }
+    let q = this.table.search(embedding).where(predicates.join(" AND "));
+    if (opts.limit !== void 0) q = q.limit(opts.limit);
+    const results = await q.toArray();
+    return results.filter((r) => opts.sources === void 0 || opts.sources.includes(r.source)).map((r) => ({
+      id: r.id,
+      text: r.text,
+      source: r.source,
+      namespace: r.namespace,
+      scope: r.scope,
+      userId: r.user_id,
+      // Lower _distance = better match; normalize to 0..1 (1=best).
+      score: 1 / (1 + (r._distance ?? 1))
+    }));
+  }
+  async countFacts(namespace) {
+    return this.table.countRows();
+  }
+  async removeFacts(ids) {
+    if (ids.length === 0) return;
+    const escaped = ids.map((id) => `'${id.replace(/'/g, "''")}'`).join(", ");
+    await this.table.delete(`id IN (${escaped})`);
+  }
+  async close() {
+  }
+};
+function escapeSqlValue(value) {
+  for (let i = 0; i < value.length; i++) {
+    const code = value.charCodeAt(i);
+    if (code === 0 || code >= 1 && code <= 31 || code === 127) {
+      throw new errors.ConfigurationError(
+        `SQL filter value contains control character at position ${i} (0x${code.toString(16)}). This may indicate an injection attempt.`,
+        { code: "sql_injection_blocked" }
+      );
+    }
+  }
+  return value.replace(/\\/g, "\\\\").replace(/'/g, "''");
+}
+function isLanceAvailable() {
+  try {
+    const r = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
+    r("@lancedb/lancedb");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function lanceStoragePath(cwd) {
+  return path.join(cwd, ".theokit", "memory", "lance");
+}
+
+// src/internal/memory-index.ts
+function parseSearchOptions(options = {}) {
+  return {
+    maxResults: Math.max(1, options.maxResults ?? 10),
+    minScore: options.minScore ?? 0
+  };
+}
+
+// src/internal/lance-memory-adapter.ts
+var DEFAULT_NAMESPACE = "default";
+var EMPTY_SYNC_RESULT = Object.freeze({
+  filesScanned: 0,
+  filesUpdated: 0,
+  chunksWritten: 0,
+  chunksEmbedded: 0
+});
+var LanceMemoryAdapter = class {
+  constructor(inner) {
+    this.inner = inner;
+  }
+  inner;
+  /**
+   * No-op for Lance — see file header. Returns zero counts so callers'
+   * existing logging (`filesScanned: X`) does not break.
+   */
+  async sync() {
+    return EMPTY_SYNC_RESULT;
+  }
+  // jscpd:ignore-start — search signature + early-out is idiomatic
+  // overlap with IndexManager.search; further factoring would hurt
+  // readability (the bodies diverge sharply right after).
+  async search(query, options = {}) {
+    if (query.trim().length === 0) return [];
+    const { maxResults, minScore } = parseSearchOptions(options);
+    const lanceHits = await this.inner.search(query, {
+      namespace: DEFAULT_NAMESPACE,
+      limit: maxResults * 2,
+      ...options.sources !== void 0 ? { sources: options.sources } : {}
+    });
+    return lanceHits.filter((h) => h.score >= minScore).slice(0, maxResults).map((h) => translateLanceHit(h));
+  }
+  status() {
+    return {
+      backend: "hybrid",
+      filesIndexed: 0,
+      chunksIndexed: 0
+    };
+  }
+  async close() {
+    await this.inner.close();
+  }
+  /**
+   * Escape hatch for advanced callers (migration tool, benchmark script)
+   * that need direct access to addFacts/countFacts/removeFacts.
+   */
+  unwrap() {
+    return this.inner;
+  }
+};
+function translateLanceHit(hit) {
+  return {
+    path: hit.id,
+    startLine: 0,
+    endLine: 0,
+    score: hit.score,
+    textScore: 0,
+    vectorScore: hit.score,
+    snippet: hit.text.slice(0, 200),
+    source: hit.source,
+    citation: hit.id
+  };
+}
+
+// src/internal/index-manager-dispatch.ts
+var VALID_BACKENDS = ["sqlite-vec", "lance"];
+function assertValidBackend(backend) {
+  if (!VALID_BACKENDS.includes(backend)) {
+    throw new errors.ConfigurationError(
+      `Invalid memory backend "${backend}". Valid values: ${VALID_BACKENDS.join(", ")}.`,
+      { code: "invalid_memory_backend" }
+    );
+  }
+}
+async function openLanceIndex(opts) {
+  if (opts.embedding === void 0) {
+    throw new errors.ConfigurationError(
+      "Lance backend requires an embedding runtime. Pass `embedding: { provider, model, apiKey }` in Memory.create options (or omit `backend` to use SQLite default).",
+      { code: "lance_requires_embedding" }
+    );
+  }
+  const lance = await LanceIndex.open({
+    cwd: opts.cwd,
+    embedding: opts.embedding,
+    ...opts.filePath !== void 0 ? { storagePath: opts.filePath } : {}
+  });
+  return new LanceMemoryAdapter(lance);
+}
+var MAX_TURN_CHARS = 2e3;
+function sessionsDir(cwd) {
+  return path.join(memoryDir(cwd), "sessions");
+}
+function sessionSummaryPath(cwd, runId) {
+  return path.join(sessionsDir(cwd), `${sanitizeRunId2(runId)}.md`);
+}
+function sanitizeRunId2(runId) {
+  return runId.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 128);
+}
+function truncate2(text) {
+  if (text.length <= MAX_TURN_CHARS) return text;
+  return `${text.slice(0, MAX_TURN_CHARS)}\u2026`;
+}
+async function writeSessionSummary(input) {
+  if (input.status !== "finished") return;
+  const path = sessionSummaryPath(input.cwd, input.runId);
+  await promises.mkdir(sessionsDir(input.cwd), { recursive: true });
+  const safeUser = redactSecrets(truncate2(input.userText));
+  const safeAssistant = redactSecrets(truncate2(input.assistantText));
+  const iso = new Date(input.at).toISOString();
+  const body = [
+    "---",
+    `runId: ${input.runId}`,
+    `agentId: ${input.agentId}`,
+    `at: ${iso}`,
+    `status: ${input.status}`,
+    "---",
+    "",
+    "## User",
+    "",
+    safeUser,
+    "",
+    "## Assistant",
+    "",
+    safeAssistant,
+    ""
+  ].join("\n");
+  await persistence.replaceFileAtomic(path, body);
+}
+
+// src/internal/session-loader.ts
+async function discoverSessionFiles(cwd) {
+  let entries;
+  try {
+    entries = await promises.readdir(sessionsDir(cwd));
+  } catch {
+    return [];
+  }
+  const root = memoryDir(cwd);
+  return entries.filter((entry) => entry.endsWith(".md")).map((entry) => {
+    const absolutePath = path.join(sessionsDir(cwd), entry);
+    return {
+      absolutePath,
+      relPath: relativeToRoot(root, absolutePath)
+    };
+  });
+}
+function relativeToRoot(root, absolutePath) {
+  if (absolutePath.startsWith(`${root}/`)) return absolutePath.slice(root.length + 1);
+  return absolutePath;
+}
+async function loadSqliteVecExtension(db) {
+  try {
+    const mod = await import('sqlite-vec');
+    const loadFn = mod.load;
+    if (typeof loadFn !== "function") {
+      throw new Error("sqlite-vec module exposes no `load` export");
+    }
+    loadFn(db);
+  } catch (cause) {
+    const message = cause instanceof Error ? cause.message : String(cause);
+    throw new errors.ConfigurationError(
+      `sqlite-vec extension unavailable. Install \`sqlite-vec\` and ensure the native binary matches your Node + OS. Cause: ${message}`,
+      { code: "sqlite_vec_unavailable", cause }
+    );
+  }
+}
+function isSqliteVecLoaded(db) {
+  try {
+    const row = db.prepare("SELECT vec_version() as v").get();
+    return row !== void 0 && row.v !== void 0;
+  } catch {
+    return false;
+  }
+}
+
+// src/internal/vec-index.ts
+var META_KEY_PROVIDER_ID = "embedding.providerId";
+var META_KEY_MODEL = "embedding.model";
+var META_KEY_DIMENSION = "embedding.dimension";
+function readEmbeddingIdentity(db) {
+  const get = (key) => {
+    const row = db.prepare("SELECT value FROM meta WHERE key = ?").get(key);
+    return row !== void 0 ? String(row.value) : void 0;
+  };
+  const providerId = get(META_KEY_PROVIDER_ID);
+  const model = get(META_KEY_MODEL);
+  const dimRaw = get(META_KEY_DIMENSION);
+  if (providerId === void 0 || model === void 0 || dimRaw === void 0) return void 0;
+  const dimension = Number(dimRaw);
+  if (!Number.isFinite(dimension) || dimension <= 0) return void 0;
+  return { providerId, model, dimension };
+}
+function writeEmbeddingIdentity(db, identity) {
+  const stmt = db.prepare(
+    "INSERT INTO meta (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value"
+  );
+  stmt.run(META_KEY_PROVIDER_ID, identity.providerId);
+  stmt.run(META_KEY_MODEL, identity.model);
+  stmt.run(META_KEY_DIMENSION, String(identity.dimension));
+}
+function identityMatches(a, b) {
+  return a.providerId === b.providerId && a.model === b.model && a.dimension === b.dimension;
+}
+function dropVectorIndex(db) {
+  db.exec("DROP TABLE IF EXISTS embeddings");
+}
+function createVectorIndex(db, dimension) {
+  db.exec(`CREATE VIRTUAL TABLE IF NOT EXISTS embeddings USING vec0(
+    chunk_id INTEGER PRIMARY KEY,
+    vec FLOAT[${dimension}]
+  )`);
+}
+function packVector(vec) {
+  const f32 = new Float32Array(vec.length);
+  for (let i = 0; i < vec.length; i++) f32[i] = vec[i] ?? 0;
+  return Buffer.from(f32.buffer);
+}
+function upsertEmbedding(db, chunkId, vec) {
+  const id = BigInt(chunkId);
+  db.prepare("DELETE FROM embeddings WHERE chunk_id = ?").run(id);
+  db.prepare("INSERT INTO embeddings (chunk_id, vec) VALUES (?, ?)").run(id, packVector(vec));
+}
+function vectorSearch(db, query, k) {
+  const rows = db.prepare(
+    `SELECT chunk_id, distance FROM embeddings
+       WHERE vec MATCH ? AND k = ?
+       ORDER BY distance`
+  ).all(packVector(query), BigInt(k));
+  return rows.map((row) => ({ chunk_id: Number(row.chunk_id), distance: Number(row.distance) }));
+}
+async function embedMissingChunks(args) {
+  const rows = args.db.prepare(
+    `SELECT chunks.id as id, chunks.text as text
+       FROM chunks
+       LEFT JOIN embeddings ON embeddings.chunk_id = chunks.id
+       WHERE embeddings.chunk_id IS NULL`
+  ).all();
+  if (rows.length === 0) return 0;
+  const normalized = rows.map((row) => ({ id: Number(row.id), text: String(row.text ?? "") }));
+  const vectors = await args.runtime.embed(normalized.map((r) => r.text));
+  for (let i = 0; i < normalized.length; i++) {
+    const row = normalized[i];
+    const vector = vectors[i];
+    if (row === void 0 || vector === void 0) continue;
+    upsertEmbedding(args.db, row.id, vector);
+  }
+  return normalized.length;
+}
+function wikiDir(cwd) {
+  return path.join(memoryDir(cwd), "wiki");
+}
+async function discoverWikiFiles(cwd) {
+  let entries;
+  try {
+    entries = await promises.readdir(wikiDir(cwd));
+  } catch {
+    return [];
+  }
+  const root = memoryDir(cwd);
+  return entries.filter((entry) => entry.endsWith(".md")).map((entry) => ({
+    absolutePath: path.join(wikiDir(cwd), entry),
+    relPath: path.join("wiki", entry)
+  })).map((file) => ({
+    absolutePath: file.absolutePath,
+    relPath: relativeToRoot2(root, file.absolutePath)
+  }));
+}
+function relativeToRoot2(root, absolutePath) {
+  if (absolutePath.startsWith(`${root}/`)) return absolutePath.slice(root.length + 1);
+  return absolutePath;
+}
+
+// src/internal/index-manager.ts
+var IndexManager = class _IndexManager {
+  constructor(cwd, db, embedding) {
+    this.cwd = cwd;
+    this.db = db;
+    this.embedding = embedding;
+  }
+  cwd;
+  db;
+  embedding;
+  lastSyncMs;
+  vectorReady = false;
+  static async open(opts) {
+    const backend = opts.backend ?? "sqlite-vec";
+    assertValidBackend(backend);
+    if (backend === "lance") return await openLanceIndex(opts);
+    return await _IndexManager.openSqliteInternal(opts);
+  }
+  /** Internal SQLite-path open. Renamed from previous public `open`. */
+  static async openSqliteInternal(opts) {
+    const filePath = opts.filePath ?? defaultIndexPath(opts.cwd);
+    const db = await openMemoryDb({ filePath });
+    const manager = new _IndexManager(opts.cwd, db, opts.embedding);
+    if (opts.embedding !== void 0) await manager.initVectorBackend(opts.embedding);
+    return manager;
+  }
+  async initVectorBackend(runtime) {
+    await loadSqliteVecExtension(this.db);
+    const currentIdentity = {
+      providerId: runtime.id,
+      model: runtime.model,
+      dimension: runtime.dimension
+    };
+    const persisted = readEmbeddingIdentity(this.db);
+    if (persisted !== void 0 && !identityMatches(persisted, currentIdentity)) {
+      dropVectorIndex(this.db);
+    }
+    createVectorIndex(this.db, runtime.dimension);
+    writeEmbeddingIdentity(this.db, currentIdentity);
+    this.vectorReady = true;
+  }
+  /** Walk the memory corpus + (re)index changed files. */
+  async sync() {
+    const files = await collectMarkdownFiles(this.cwd);
+    let filesUpdated = 0;
+    let chunksWritten = 0;
+    const existingByPath = this.loadFilesIndex();
+    for (const entry of files) {
+      const raw = await promises.readFile(entry.absolutePath, "utf8");
+      const hash = sha256(raw);
+      const existing = existingByPath.get(entry.absolutePath);
+      if (existing !== void 0 && existing.hash === hash) continue;
+      const stats = await promises.stat(entry.absolutePath);
+      const fileId = this.upsertFile(
+        entry.absolutePath,
+        entry.relPath,
+        hash,
+        stats.mtimeMs,
+        entry.source
+      );
+      this.deleteChunksForFile(fileId);
+      const chunks = chunkMarkdown(raw);
+      for (const chunk of chunks) {
+        this.insertChunk(fileId, chunk.startLine, chunk.endLine, chunk.text, chunk.hash);
+      }
+      filesUpdated += 1;
+      chunksWritten += chunks.length;
+    }
+    let chunksEmbedded = 0;
+    if (this.vectorReady && this.embedding !== void 0) {
+      chunksEmbedded = await embedMissingChunks({ db: this.db, runtime: this.embedding });
+    }
+    this.lastSyncMs = Date.now();
+    return { filesScanned: files.length, filesUpdated, chunksWritten, chunksEmbedded };
+  }
+  async search(query, options = {}) {
+    if (query.trim().length === 0) return [];
+    const { maxResults, minScore } = parseSearchOptions(options);
+    const textHits = this.ftsSearch(query, maxResults * 2);
+    const vectorHitsById = await this.vectorSearchById(query, maxResults * 2);
+    const combined = this.combineHybridScores(textHits, vectorHitsById, options);
+    return combined.filter((h) => h.score >= minScore).filter((h) => options.sources === void 0 || options.sources.includes(h.source)).slice(0, maxResults);
+  }
+  status() {
+    const files = this.db.prepare("SELECT COUNT(*) as n FROM files").get() ?? { n: 0 };
+    const chunks = this.db.prepare("SELECT COUNT(*) as n FROM chunks").get() ?? { n: 0 };
+    const status = {
+      backend: this.vectorReady ? "hybrid" : "fts-only",
+      filesIndexed: Number(files.n ?? 0),
+      chunksIndexed: Number(chunks.n ?? 0)
+    };
+    if (this.lastSyncMs !== void 0) status.lastSyncMs = this.lastSyncMs;
+    return status;
+  }
+  // ───── search internals ──────────────────────────────────────────────
+  ftsSearch(query, limit) {
+    const sanitized = persistence.sanitizeFts5Query(query);
+    if (sanitized.length === 0) return [];
+    const stmt = this.db.prepare(
+      `SELECT chunks.id as id, files.rel_path as rel_path, files.source as source,
+              chunks.start_line as start_line, chunks.end_line as end_line,
+              chunks.text as text, bm25(chunks_fts) as bm25_score
+       FROM chunks_fts
+       JOIN chunks ON chunks_fts.rowid = chunks.id
+       JOIN files  ON chunks.file_id = files.id
+       WHERE chunks_fts MATCH ?
+       ORDER BY bm25_score
+       LIMIT ?`
+    );
+    let rows = [];
+    try {
+      rows = stmt.all(sanitized, limit);
+    } catch {
+      return [];
+    }
+    return rows.map((row) => {
+      const bm25 = Number(row.bm25_score ?? 0);
+      const textScore = bm25 < 0 ? 1 / (1 + Math.abs(bm25)) : 1 / (1 + bm25);
+      const startLine = Number(row.start_line ?? 0);
+      const endLine = Number(row.end_line ?? 0);
+      const path = String(row.rel_path);
+      return {
+        path,
+        startLine,
+        endLine,
+        score: textScore,
+        textScore,
+        snippet: truncateSnippet(String(row.text ?? "")),
+        source: String(row.source),
+        citation: `${path}:${startLine}-${endLine}`,
+        // sneak the chunk id through for the hybrid join below
+        // (cast away later)
+        chunkId: Number(row.id)
+      };
+    });
+  }
+  async vectorSearchById(query, limit) {
+    if (!this.vectorReady || this.embedding === void 0) return /* @__PURE__ */ new Map();
+    const [queryVec] = await this.embedding.embed([query]);
+    if (queryVec === void 0) return /* @__PURE__ */ new Map();
+    const rows = vectorSearch(this.db, queryVec, limit);
+    const out = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      const score = 1 / (1 + Math.max(0, row.distance));
+      out.set(row.chunk_id, { vectorScore: score });
+    }
+    return out;
+  }
+  combineHybridScores(textHits, vectorHitsById, options) {
+    const weights = resolveWeights(options);
+    const merged = this.mergeHits(textHits, vectorHitsById);
+    const combined = [...merged.values()].map(
+      (hit) => blendScores(hit, vectorHitsById.get(hit.chunkId)?.vectorScore ?? 0, weights)
+    );
+    return combined.sort((a, b) => b.score - a.score);
+  }
+  mergeHits(textHits, vectorHitsById) {
+    const merged = /* @__PURE__ */ new Map();
+    for (const hit of textHits) merged.set(hit.chunkId, hit);
+    const missingIds = [...vectorHitsById.keys()].filter((id) => !merged.has(id));
+    if (missingIds.length > 0) {
+      for (const hit of this.fetchChunksByIds(missingIds)) {
+        merged.set(hit.chunkId, { ...hit, score: 0, textScore: 0 });
+      }
+    }
+    return merged;
+  }
+  fetchChunksByIds(ids) {
+    if (ids.length === 0) return [];
+    const placeholders = ids.map(() => "?").join(",");
+    const rows = this.db.prepare(
+      `SELECT chunks.id as id, files.rel_path as rel_path, files.source as source,
+                chunks.start_line as start_line, chunks.end_line as end_line,
+                chunks.text as text
+         FROM chunks JOIN files ON chunks.file_id = files.id
+         WHERE chunks.id IN (${placeholders})`
+    ).all(...ids);
+    return rows.map((row) => {
+      const startLine = Number(row.start_line ?? 0);
+      const endLine = Number(row.end_line ?? 0);
+      const path = String(row.rel_path);
+      return {
+        chunkId: Number(row.id),
+        path,
+        startLine,
+        endLine,
+        score: 0,
+        textScore: 0,
+        snippet: truncateSnippet(String(row.text ?? "")),
+        source: String(row.source),
+        citation: `${path}:${startLine}-${endLine}`
+      };
+    });
+  }
+  // ───── persistence helpers ─────────────────────────────────────────
+  loadFilesIndex() {
+    const rows = this.db.prepare("SELECT id, path, hash FROM files").all();
+    return new Map(rows.map((row) => [row.path, { id: row.id, hash: row.hash }]));
+  }
+  upsertFile(absPath, relPath, hash, mtimeMs, source = "memory") {
+    const stmt = this.db.prepare(
+      `INSERT INTO files (path, rel_path, mtime, hash, source) VALUES (?, ?, ?, ?, ?)
+       ON CONFLICT(path) DO UPDATE SET hash = excluded.hash, mtime = excluded.mtime, source = excluded.source
+       RETURNING id`
+    );
+    const row = stmt.get(absPath, relPath, Math.floor(mtimeMs), hash, source);
+    return row.id;
+  }
+  deleteChunksForFile(fileId) {
+    this.db.prepare("DELETE FROM chunks WHERE file_id = ?").run(fileId);
+  }
+  insertChunk(fileId, startLine, endLine, text, hash) {
+    this.db.prepare(
+      "INSERT INTO chunks (file_id, start_line, end_line, text, hash) VALUES (?, ?, ?, ?, ?)"
+    ).run(fileId, startLine, endLine, text, hash);
+  }
+  close() {
+    this.db.close();
+  }
+};
+function resolveWeights(options) {
+  const vectorWeight = options.vectorWeight ?? 0.6;
+  const textWeight = options.textWeight ?? 0.4;
+  const total = vectorWeight + textWeight || 1;
+  return { vectorWeight, textWeight, total };
+}
+function blendScores(hit, vectorScore, weights) {
+  const score = (vectorScore * weights.vectorWeight + hit.textScore * weights.textWeight) / weights.total;
+  return {
+    path: hit.path,
+    startLine: hit.startLine,
+    endLine: hit.endLine,
+    score,
+    textScore: hit.textScore,
+    snippet: hit.snippet,
+    source: hit.source,
+    citation: hit.citation,
+    ...vectorScore > 0 ? { vectorScore } : {}
+  };
+}
+async function collectMarkdownFiles(cwd) {
+  const root = memoryDir(cwd);
+  const results = [];
+  try {
+    await promises.stat(memoryMdPath(cwd));
+    results.push({
+      absolutePath: memoryMdPath(cwd),
+      relPath: path.relative(root, memoryMdPath(cwd)),
+      source: "memory"
+    });
+  } catch {
+  }
+  try {
+    const entries = await promises.readdir(notesDir(cwd));
+    for (const entry of entries) {
+      if (!entry.endsWith(".md")) continue;
+      const abs = path.join(notesDir(cwd), entry);
+      results.push({ absolutePath: abs, relPath: path.relative(root, abs), source: "memory" });
+    }
+  } catch {
+  }
+  const wikiFiles = await discoverWikiFiles(cwd);
+  for (const wiki of wikiFiles) {
+    results.push({
+      absolutePath: wiki.absolutePath,
+      relPath: wiki.relPath,
+      source: "wiki"
+    });
+  }
+  const sessionFiles = await discoverSessionFiles(cwd);
+  for (const session of sessionFiles) {
+    results.push({
+      absolutePath: session.absolutePath,
+      relPath: session.relPath,
+      source: "sessions"
+    });
+  }
+  return results;
+}
+function sha256(text) {
+  return crypto.createHash("sha256").update(text).digest("hex");
+}
+function truncateSnippet(text) {
+  const max = 500;
+  return text.length <= max ? text : `${text.slice(0, max)}\u2026`;
+}
+async function readAllSqliteFacts(cwd) {
+  const dbPath = defaultIndexPath(cwd);
+  if (!fs.existsSync(dbPath)) return [];
+  const db = await openMemoryDb({ filePath: dbPath });
+  try {
+    const stmt = db.prepare("SELECT id, path, source, start_line, end_line, text FROM chunks");
+    const rows = stmt.all();
+    return rows.map((r) => ({
+      ...r,
+      namespace: "default",
+      scope: "agent",
+      user_id: "default"
+    }));
+  } finally {
+    db.close();
+  }
+}
+function nfcEqual(a, b) {
+  return a.normalize("NFC") === b.normalize("NFC");
+}
+async function migrateSqliteToLance(opts) {
+  const cwd = opts.cwd;
+  const finalPath = lanceStoragePath(cwd);
+  const newPath = path.join(cwd, ".theokit", "memory", "lance-new");
+  const rawLog = opts.logger ?? ((m) => console.log(m));
+  const log = (m) => rawLog(redactSecrets(m));
+  if (fs.existsSync(finalPath)) {
+    throw new errors.ConfigurationError(
+      `Destination already exists: ${finalPath}. Remove it manually (\`rm -rf ${finalPath}\`) and re-run.`,
+      { code: "migration_destination_exists" }
+    );
+  }
+  if (fs.existsSync(newPath)) {
+    log(`Removing stale ${newPath} from a previous run...`);
+    fs.rmSync(newPath, { recursive: true, force: true });
+  }
+  log(`Reading SQLite facts from ${cwd}/.theokit/memory/index.sqlite ...`);
+  const sqliteFacts = await readAllSqliteFacts(cwd);
+  log(`SQLite has ${sqliteFacts.length} facts.`);
+  if (sqliteFacts.length === 0) {
+    return {
+      countSqlite: 0,
+      countLance: 0,
+      validated: true,
+      sampleComparisons: [],
+      lancePath: finalPath,
+      committed: false
+    };
+  }
+  const placeholderEmbedding = {
+    id: "migration-placeholder",
+    model: "deterministic-hash",
+    dimension: 8,
+    embed: async (texts) => {
+      return texts.map((t) => {
+        const arr = new Array(8).fill(0);
+        for (let i = 0; i < t.length; i += 1) {
+          arr[i % 8] += t.charCodeAt(i);
+        }
+        return arr.map((x) => x / 1e3);
+      });
+    },
+    stats: () => ({ cacheHits: 0, cacheMisses: 0, httpCalls: 0, retries: 0 })
+  };
+  fs.mkdirSync(newPath, { recursive: true });
+  log(`Writing Lance index to ${newPath} ...`);
+  const lance = await LanceIndex.open({
+    cwd,
+    embedding: placeholderEmbedding,
+    storagePath: newPath
+  });
+  const batchSize = opts.batchSize ?? 100;
+  for (let i = 0; i < sqliteFacts.length; i += batchSize) {
+    const batch = sqliteFacts.slice(i, i + batchSize).map((f) => ({
+      id: f.id,
+      text: f.text,
+      source: f.source,
+      namespace: f.namespace ?? "default",
+      scope: f.scope ?? "agent",
+      user_id: f.user_id ?? "default",
+      timestamp: 0
+    }));
+    await lance.addFacts(batch);
+    log(`  Migrated ${Math.min(i + batchSize, sqliteFacts.length)}/${sqliteFacts.length}`);
+  }
+  const lanceCount = await lance.countFacts("default");
+  log(`Lance has ${lanceCount} facts (expected ${sqliteFacts.length}).`);
+  const sampleSize = Math.min(10, sqliteFacts.length);
+  const sampleComparisons = [];
+  for (let i = 0; i < sampleSize; i += 1) {
+    const sqliteFact = sqliteFacts[Math.floor(i * sqliteFacts.length / sampleSize)];
+    if (sqliteFact === void 0) continue;
+    const hits = await lance.search(sqliteFact.text, {
+      namespace: sqliteFact.namespace ?? "default",
+      limit: 1
+    });
+    const hit = hits[0];
+    const match = hit !== void 0 && nfcEqual(hit.text, sqliteFact.text);
+    sampleComparisons.push({ id: sqliteFact.id, match });
+  }
+  const allMatch = sampleComparisons.every((c) => c.match);
+  const countMatch = lanceCount === sqliteFacts.length;
+  const validated = allMatch && countMatch;
+  await lance.close();
+  if (opts.dryRun === true) {
+    log("Dry-run mode \u2014 discarding Lance staging dir.");
+    fs.rmSync(newPath, { recursive: true, force: true });
+    return {
+      countSqlite: sqliteFacts.length,
+      countLance: lanceCount,
+      validated,
+      sampleComparisons,
+      lancePath: finalPath,
+      committed: false
+    };
+  }
+  if (!validated) {
+    log("Validation FAILED \u2014 leaving SQLite intact, removing Lance staging dir.");
+    fs.rmSync(newPath, { recursive: true, force: true });
+    return {
+      countSqlite: sqliteFacts.length,
+      countLance: lanceCount,
+      validated: false,
+      sampleComparisons,
+      lancePath: finalPath,
+      committed: false
+    };
+  }
+  fs.renameSync(newPath, finalPath);
+  log(`Migration committed to ${finalPath}.`);
+  return {
+    countSqlite: sqliteFacts.length,
+    countLance: lanceCount,
+    validated: true,
+    sampleComparisons,
+    lancePath: finalPath,
+    committed: true
+  };
+}
+async function fileExists(path) {
+  try {
+    await promises.access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readLegacyFacts(jsonPath) {
+  try {
+    const raw = await promises.readFile(jsonPath, "utf8");
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed.facts) ? parsed.facts : [];
+  } catch {
+    return void 0;
+  }
+}
+async function writeMigratedFacts(cwd, jsonPath, facts) {
+  try {
+    for (const fact of facts) await appendFactToMarkdown(cwd, fact);
+    await promises.unlink(jsonPath).catch(() => void 0);
+    process.stderr.write(
+      `[theokit-sdk] migrated ${facts.length} fact(s) from ${jsonPath} to MEMORY.md
+`
+    );
+    return { migrated: true, factCount: facts.length };
+  } catch (cause) {
+    const message = cause instanceof Error ? cause.message : String(cause);
+    process.stderr.write(`[theokit-sdk] memory migration failed (readonly fs?): ${message}
+`);
+    return { migrated: false, factCount: 0, reason: "readonly-fs" };
+  }
+}
+var migrationRun = /* @__PURE__ */ new Set();
+async function migrateLegacyJson(cwd, config) {
+  const key = `${cwd}::${config.namespace ?? "default"}::${config.scope ?? "agent"}::${config.userId ?? "default"}`;
+  if (migrationRun.has(key)) return { migrated: false, factCount: 0, reason: "already-migrated" };
+  migrationRun.add(key);
+  const jsonPath = legacyMemoryJsonPath(cwd, config);
+  if (!await fileExists(jsonPath)) {
+    return { migrated: false, factCount: 0, reason: "no-legacy-json" };
+  }
+  if (await fileExists(memoryMdPath(cwd))) {
+    process.stderr.write(
+      `[theokit-sdk] memory migration skipped: both MEMORY.md and legacy JSON exist at ${jsonPath}; leaving both intact
+`
+    );
+    return { migrated: false, factCount: 0, reason: "markdown-exists" };
+  }
+  const facts = await readLegacyFacts(jsonPath);
+  if (facts === void 0) return { migrated: false, factCount: 0, reason: "no-legacy-json" };
+  return writeMigratedFacts(cwd, jsonPath, facts);
+}
+function resetMigrationStateForTests() {
+  migrationRun.clear();
+}
+var DEFAULT_MEMORY_READ_LINES = 200;
+async function readMemoryFileBounded(opts) {
+  const absolutePath = path.resolve(opts.cwd, opts.relPath);
+  const raw = await promises.readFile(absolutePath, "utf8");
+  const allLines = raw.split("\n");
+  const trimmedLines = allLines.length > 0 && allLines[allLines.length - 1] === "" ? allLines.slice(0, -1) : allLines;
+  const totalLines = trimmedLines.length;
+  const requestedFrom = Math.max(1, opts.from ?? 1);
+  const requestedLines = Math.max(1, opts.lines ?? DEFAULT_MEMORY_READ_LINES);
+  const startIdx = requestedFrom - 1;
+  const endIdx = Math.min(totalLines, startIdx + requestedLines);
+  const slice = trimmedLines.slice(startIdx, endIdx);
+  const linesReturned = slice.length;
+  const remainingLines = Math.max(0, totalLines - endIdx);
+  const truncated = remainingLines > 0;
+  return {
+    path: opts.relPath,
+    from: requestedFrom,
+    linesReturned,
+    totalLines,
+    truncated,
+    remainingLines,
+    text: slice.join("\n")
+  };
+}
+var SEARCH_DESCRIPTION = "Mandatory recall step: semantically search MEMORY.md + memory/notes/*.md (and optional wiki supplements) before answering questions about prior work, decisions, dates, people, preferences, or todos. `corpus=memory` (default) restricts to indexed memory files; `corpus=wiki` restricts to read-only wiki supplements; `corpus=all` returns both. Returns ranked `{ path, startLine, endLine, score, snippet, citation }` hits.";
+var GET_DESCRIPTION = "Safe exact excerpt read from MEMORY.md or memory/notes/*.md. Defaults to a bounded excerpt (200 lines). Returns `{ path, from, linesReturned, totalLines, truncated, remainingLines, text }`. Paths are resolved against the memory root \u2014 attempts to read outside `.theokit/memory/` are rejected.";
+var MEMORY_SEARCH_SCHEMA = {
+  type: "object",
+  required: ["query"],
+  properties: {
+    query: { type: "string", description: "Natural-language query." },
+    maxResults: { type: "integer", minimum: 1, maximum: 50 },
+    minScore: { type: "number", minimum: 0, maximum: 1 },
+    corpus: { type: "string", enum: ["memory", "sessions", "wiki", "all"] }
+  },
+  additionalProperties: false
+};
+var MEMORY_GET_SCHEMA = {
+  type: "object",
+  required: ["path"],
+  properties: {
+    path: { type: "string", description: "Path relative to .theokit/memory/" },
+    from: { type: "integer", minimum: 1 },
+    lines: { type: "integer", minimum: 1, maximum: 2e3 }
+  },
+  additionalProperties: false
+};
+var DEFAULT_MAX_TOTAL_CHARS = 16384;
+function createMemorySearchTool(opts) {
+  const cap = opts.maxTotalChars ?? DEFAULT_MAX_TOTAL_CHARS;
+  return {
+    name: "memory_search",
+    description: SEARCH_DESCRIPTION,
+    inputSchema: MEMORY_SEARCH_SCHEMA,
+    async execute(input) {
+      const query = readString(input.query, "query is required");
+      const maxResults = readNumber(input.maxResults) ?? 10;
+      const minScore = readNumber(input.minScore);
+      const corpus = readString(input.corpus, void 0, true);
+      const sources = mapCorpusToSources(corpus);
+      const searchOptions = {
+        maxResults,
+        ...minScore !== void 0 ? { minScore } : {},
+        ...sources !== void 0 ? { sources } : {}
+      };
+      const hits = await opts.index.search(query, searchOptions);
+      return JSON.stringify(capByTotalChars(hits, cap));
+    }
+  };
+}
+function createMemoryGetTool(opts) {
+  const memoryRoot = path.resolve(memoryDir(opts.cwd));
+  return {
+    name: "memory_get",
+    description: GET_DESCRIPTION,
+    inputSchema: MEMORY_GET_SCHEMA,
+    async execute(input) {
+      const relPath = readString(input.path, "path is required");
+      const from = readNumber(input.from);
+      const lines = readNumber(input.lines);
+      const resolved = path.resolve(memoryRoot, relPath);
+      if (!isPathInside(memoryRoot, resolved)) {
+        throw new errors.ConfigurationError(
+          `memory_get rejected path that escapes memory root: ${relPath}`,
+          { code: "memory_path_escapes_root" }
+        );
+      }
+      const readArgs = {
+        cwd: memoryRoot,
+        relPath
+      };
+      if (from !== void 0) readArgs.from = from;
+      if (lines !== void 0) readArgs.lines = lines;
+      const result = await readMemoryFileBounded(readArgs);
+      return JSON.stringify(result);
+    }
+  };
+}
+function readString(value, errorIfMissing, allowUndefined = false) {
+  if (typeof value === "string") return value;
+  if (allowUndefined && (value === void 0 || value === null)) return "";
+  if (errorIfMissing !== void 0) {
+    throw new errors.ConfigurationError(errorIfMissing, { code: "memory_tool_bad_args" });
+  }
+  return "";
+}
+function readNumber(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string" && value.trim().length > 0) {
+    const n = Number(value);
+    if (Number.isFinite(n)) return n;
+  }
+  return void 0;
+}
+function mapCorpusToSources(corpus) {
+  if (corpus === "" || corpus === "all") return void 0;
+  if (corpus === "memory") return ["memory"];
+  if (corpus === "wiki") return ["wiki"];
+  if (corpus === "sessions") return ["sessions"];
+  return void 0;
+}
+function capByTotalChars(hits, maxTotalChars) {
+  if (hits.length === 0) return { hits: [], truncated: false };
+  const kept = [];
+  let runningChars = 0;
+  for (const hit of hits) {
+    const snippetLen = hit.snippet.length + (hit.citation?.length ?? 0) + 32;
+    if (kept.length > 0 && runningChars + snippetLen > maxTotalChars) {
+      return { hits: kept, truncated: true };
+    }
+    kept.push(hit);
+    runningChars += snippetLen;
+  }
+  return { hits: kept, truncated: false };
+}
+function isPathInside(root, candidate) {
+  const normalizedRoot = root.endsWith("/") ? root : `${root}/`;
+  return candidate === root || candidate.startsWith(normalizedRoot);
+}
+
+exports.ActiveMemoryCache = ActiveMemoryCache;
+exports.CircuitBreaker = CircuitBreaker;
+exports.DEFAULT_DEEPINFRA_EMBEDDING_MODEL = DEFAULT_DEEPINFRA_EMBEDDING_MODEL;
+exports.DEFAULT_MEMORY_READ_LINES = DEFAULT_MEMORY_READ_LINES;
+exports.DEFAULT_MISTRAL_EMBEDDING_MODEL = DEFAULT_MISTRAL_EMBEDDING_MODEL;
+exports.DEFAULT_OLLAMA_EMBEDDING_MODEL = DEFAULT_OLLAMA_EMBEDDING_MODEL;
+exports.DEFAULT_OPENAI_EMBEDDING_MODEL = DEFAULT_OPENAI_EMBEDDING_MODEL;
+exports.DEFAULT_OPENROUTER_EMBEDDING_MODEL = DEFAULT_OPENROUTER_EMBEDDING_MODEL;
+exports.DEFAULT_VOYAGE_EMBEDDING_MODEL = DEFAULT_VOYAGE_EMBEDDING_MODEL;
+exports.IndexManager = IndexManager;
+exports.LanceIndex = LanceIndex;
+exports.LanceMemoryAdapter = LanceMemoryAdapter;
+exports.MEMORY_EMBEDDING_ADAPTERS = MEMORY_EMBEDDING_ADAPTERS;
+exports.META_KEY_DIMENSION = META_KEY_DIMENSION;
+exports.META_KEY_MODEL = META_KEY_MODEL;
+exports.META_KEY_PROVIDER_ID = META_KEY_PROVIDER_ID;
+exports.MIGRATION_V2_STATEMENTS = MIGRATION_V2_STATEMENTS;
+exports.PRAGMA_STATEMENTS = PRAGMA_STATEMENTS;
+exports.SCHEMA_STATEMENTS = SCHEMA_STATEMENTS;
+exports.VALID_BACKENDS = VALID_BACKENDS;
+exports.appendDiaryEntry = appendDiaryEntry;
+exports.appendFact = appendFact;
+exports.appendFactToMarkdown = appendFactToMarkdown;
+exports.assertValidBackend = assertValidBackend;
+exports.buildErrorMetadata = buildErrorMetadata;
+exports.chunkMarkdown = chunkMarkdown;
+exports.createInMemoryMarkdownProvider = createInMemoryMarkdownProvider;
+exports.createMemoryGetTool = createMemoryGetTool;
+exports.createMemorySearchTool = createMemorySearchTool;
+exports.createOpenAiCompatibleRuntime = createOpenAiCompatibleRuntime;
+exports.createVectorIndex = createVectorIndex;
+exports.deepPhase = deepPhase;
+exports.deepinfraMemoryEmbeddingProviderAdapter = deepinfraMemoryEmbeddingProviderAdapter;
+exports.defaultIndexPath = defaultIndexPath;
+exports.diaryPath = diaryPath;
+exports.discoverSessionFiles = discoverSessionFiles;
+exports.discoverWikiFiles = discoverWikiFiles;
+exports.dropVectorIndex = dropVectorIndex;
+exports.embedMissingChunks = embedMissingChunks;
+exports.entryHash = entryHash;
+exports.identityMatches = identityMatches;
+exports.isLanceAvailable = isLanceAvailable;
+exports.isSqliteVecLoaded = isSqliteVecLoaded;
+exports.lanceStoragePath = lanceStoragePath;
+exports.legacyMemoryJsonPath = legacyMemoryJsonPath;
+exports.lightPhase = lightPhase;
+exports.listNotes = listNotes;
+exports.loadSqliteVecExtension = loadSqliteVecExtension;
+exports.mapOpenAICompatibleError = mapOpenAICompatibleError;
+exports.memoryDir = memoryDir;
+exports.memoryMdPath = memoryMdPath;
+exports.migrateLegacyJson = migrateLegacyJson;
+exports.migrateSqliteToLance = migrateSqliteToLance;
+exports.mistralMemoryEmbeddingProviderAdapter = mistralMemoryEmbeddingProviderAdapter;
+exports.notesDir = notesDir;
+exports.ollamaMemoryEmbeddingProviderAdapter = ollamaMemoryEmbeddingProviderAdapter;
+exports.openAiMemoryEmbeddingProviderAdapter = openAiMemoryEmbeddingProviderAdapter;
+exports.openLanceIndex = openLanceIndex;
+exports.openMemoryDb = openMemoryDb;
+exports.openRouterMemoryEmbeddingProviderAdapter = openRouterMemoryEmbeddingProviderAdapter;
+exports.packVector = packVector;
+exports.parseRetryAfter = parseRetryAfter;
+exports.parseSearchOptions = parseSearchOptions;
+exports.persistActiveMemoryTranscript = persistActiveMemoryTranscript;
+exports.readEmbeddingIdentity = readEmbeddingIdentity;
+exports.readFacts = readFacts;
+exports.readFactsFromMarkdown = readFactsFromMarkdown;
+exports.readMemoryFileBounded = readMemoryFileBounded;
+exports.redactSecrets = redactSecrets;
+exports.remPhase = remPhase;
+exports.renderDiaryEntry = renderDiaryEntry;
+exports.resetMigrationStateForTests = resetMigrationStateForTests;
+exports.runActiveMemory = runActiveMemory;
+exports.runDreamingSweep = runDreamingSweep;
+exports.sessionSummaryPath = sessionSummaryPath;
+exports.sessionsDir = sessionsDir;
+exports.truncateRaw = truncateRaw;
+exports.upsertEmbedding = upsertEmbedding;
+exports.vectorSearch = vectorSearch;
+exports.voyageMemoryEmbeddingProviderAdapter = voyageMemoryEmbeddingProviderAdapter;
+exports.wikiDir = wikiDir;
+exports.writeEmbeddingIdentity = writeEmbeddingIdentity;
+exports.writeSessionSummary = writeSessionSummary;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map