@theokit/sdk-memory 0.1.0 → 0.2.0

package/dist/index.cjs

@@ -252,7 +252,7 @@ function legacyMemoryJsonPath(cwd, config) {
   return pathSafety.safePathJoin(cwd, ".theokit", "memory", namespace, `${scope}-${userId}.json`);
 }
 
-// src/internal/markdown-store.ts
+// src/internal/store/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) {
@@ -343,7 +343,7 @@ async function appendFact(cwd, config, fact) {
   await appendFactToMarkdown(cwd, fact);
 }
 
-// src/internal/transcript-store.ts
+// src/internal/store/transcript-store.ts
 async function persistActiveMemoryTranscript(cwd, transcript) {
   try {
     const dir = path.join(memoryDir(cwd), "transcripts", "active-memory");
@@ -356,7 +356,7 @@ async function persistActiveMemoryTranscript(cwd, transcript) {
   }
 }
 
-// src/internal/active-memory.ts
+// src/internal/active-memory/active-memory.ts
 var SPAN_MEMORY_RECALL = "memory.recall";
 var HISTOGRAM_MEMORY_RECALL_DURATION_MS = "theokit_memory_recall_duration_ms";
 var DEFAULTS = {
@@ -705,7 +705,7 @@ function formatMessage(providerId, status, code) {
   return `${providerId} API error: ${code} (HTTP ${status})`;
 }
 
-// src/internal/embedding-cache.ts
+// src/internal/embedding/embedding-cache.ts
 var LruEmbeddingCache = class {
   constructor(capacity = 5e3) {
     this.capacity = capacity;
@@ -732,7 +732,7 @@ var LruEmbeddingCache = class {
   }
 };
 
-// src/internal/openai-compatible.ts
+// src/internal/embedding/openai-compatible.ts
 var MAX_BATCH = 100;
 var MAX_RETRIES = 2;
 async function createOpenAiCompatibleRuntime(cfg, options) {
@@ -903,7 +903,7 @@ function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
-// src/internal/deepinfra-embedding.ts
+// src/internal/embedding/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,
@@ -937,7 +937,7 @@ var deepinfraMemoryEmbeddingProviderAdapter = {
   )
 };
 
-// src/internal/mistral-embedding.ts
+// src/internal/embedding/mistral-embedding.ts
 var DEFAULT_MISTRAL_EMBEDDING_MODEL = "mistral-embed";
 var DIMENSION_BY_MODEL2 = {
   "mistral-embed": 1024
@@ -961,7 +961,7 @@ var mistralMemoryEmbeddingProviderAdapter = {
   )
 };
 
-// src/internal/ollama-embedding.ts
+// src/internal/embedding/ollama-embedding.ts
 var DEFAULT_OLLAMA_EMBEDDING_MODEL = "nomic-embed-text";
 var OLLAMA_LOCAL_SENTINEL_KEY = "ollama-local";
 var DIMENSION_BY_MODEL3 = {
@@ -1004,7 +1004,7 @@ var ollamaMemoryEmbeddingProviderAdapter = {
   }
 };
 
-// src/internal/openai-embedding.ts
+// src/internal/embedding/openai-embedding.ts
 var DEFAULT_OPENAI_EMBEDDING_MODEL = "text-embedding-3-small";
 var DIMENSION_BY_MODEL4 = {
   "text-embedding-3-small": 1536,
@@ -1030,7 +1030,7 @@ var openAiMemoryEmbeddingProviderAdapter = {
   )
 };
 
-// src/internal/openrouter-embedding.ts
+// src/internal/embedding/openrouter-embedding.ts
 var DEFAULT_OPENROUTER_EMBEDDING_MODEL = "openai/text-embedding-3-small";
 var DIMENSION_BY_MODEL5 = {
   "openai/text-embedding-3-small": 1536,
@@ -1057,7 +1057,7 @@ var openRouterMemoryEmbeddingProviderAdapter = {
   )
 };
 
-// src/internal/voyage-embedding.ts
+// src/internal/embedding/voyage-embedding.ts
 var DEFAULT_VOYAGE_EMBEDDING_MODEL = "voyage-3-lite";
 var DIMENSION_BY_MODEL6 = {
   "voyage-3-lite": 512,
@@ -1094,80 +1094,131 @@ var MEMORY_EMBEDDING_ADAPTERS = {
   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);
+var FACTS_HEADING2 = "## Facts";
+function createCategorizedMemory(options) {
+  const { root, categories } = options;
+  validateCategories(categories);
+  const allowed = new Set(categories);
+  function assertKnown(category) {
+    if (!allowed.has(category)) {
+      throw new errors.ConfigurationError(
+        `createCategorizedMemory: unknown category ${JSON.stringify(category)} (declared: ${categories.join(", ")})`,
+        { code: "unknown_category" }
+      );
+    }
   }
-  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);
+  function categoryPath(category) {
+    return pathSafety.safePathJoin(root, `${pathSafety.sanitizeIdentifier(category)}.md`);
+  }
+  async function add(category, text) {
+    assertKnown(category);
+    const encoded = encodeFact(redactSecrets(text));
+    const sane = pathSafety.sanitizeIdentifier(category);
+    await persistence.withCwdMutex(`catmem:${root}:${sane}`, async () => {
+      const path = pathSafety.safePathJoin(root, `${sane}.md`);
+      const raw = await readFileOrEmpty(path) || header(category);
+      await promises.mkdir(root, { recursive: true });
+      await persistence.replaceFileAtomic(path, appendBullet(raw, encoded));
+    });
   }
-  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);
+  async function list(category) {
+    if (category !== void 0) {
+      assertKnown(category);
+      return readCategory(categoryPath(category), category);
+    }
+    const out = [];
+    for (const c of categories) {
+      out.push(...await readCategory(categoryPath(c), c));
+    }
+    return out;
   }
+  return { categories: [...categories], add, list };
 }
-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;
+function validateCategories(categories) {
+  if (categories.length === 0) {
+    throw new errors.ConfigurationError("createCategorizedMemory: categories must be non-empty", {
+      code: "invalid_categories"
+    });
   }
-  if (chunkText.length > maxChars) {
-    pushOversizedSlices(acc.chunks, chunkText, acc.start, acc.heading, maxChars);
-  } else {
-    acc.chunks.push(buildChunk(chunkText, acc.start, endLineExclusive, acc.heading));
+  if (new Set(categories).size !== categories.length) {
+    throw new errors.ConfigurationError("createCategorizedMemory: categories must be unique", {
+      code: "invalid_categories"
+    });
+  }
+  const sanitized = categories.map((c) => trySanitize(c));
+  if (new Set(sanitized).size !== categories.length) {
+    throw new errors.ConfigurationError(
+      "createCategorizedMemory: categories must map to distinct filenames after sanitization",
+      { code: "invalid_categories" }
+    );
   }
-  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;
+function trySanitize(category) {
+  try {
+    return pathSafety.sanitizeIdentifier(category);
+  } catch (cause) {
+    throw new errors.ConfigurationError(
+      `createCategorizedMemory: category ${JSON.stringify(category)} is not a valid identifier`,
+      { code: "invalid_categories", cause }
+    );
   }
-  if (remaining.length > 0) {
-    const sliceLines = remaining.split("\n").length;
-    chunks.push(buildChunk(remaining, lineCursor, lineCursor + sliceLines - 1, heading));
+}
+function header(category) {
+  return `---
+category: ${category}
+---
+
+${FACTS_HEADING2}
+`;
+}
+async function readFileOrEmpty(path) {
+  try {
+    return await promises.readFile(path, "utf8");
+  } catch {
+    return "";
   }
 }
-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;
+async function readCategory(path, category) {
+  const raw = await readFileOrEmpty(path);
+  return parseFactBullets(raw).map((text) => ({ text: decodeFact(text), category }));
+}
+function encodeFact(text) {
+  return text.replace(/\\/g, "\\\\").replace(/\r/g, "\\r").replace(/\n/g, "\\n");
+}
+function decodeFact(text) {
+  return text.replace(
+    /\\(.)/g,
+    (_match, char) => char === "n" ? "\n" : char === "r" ? "\r" : char
+  );
+}
+function parseFactBullets(raw) {
+  const idx = raw.indexOf(FACTS_HEADING2);
+  if (idx === -1) return [];
+  const tail = raw.slice(idx + FACTS_HEADING2.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) => line.slice(2).trim());
+}
+function appendBullet(raw, text) {
+  const bullet = `- ${text}`;
+  const idx = raw.indexOf(FACTS_HEADING2);
+  if (idx === -1) {
+    const sep = raw.endsWith("\n") ? "" : "\n";
+    return `${raw}${sep}${FACTS_HEADING2}
+
+${bullet}
+`;
   }
-  return maxChars;
+  const after = idx + FACTS_HEADING2.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)}`;
 }
 function diaryPath(cwd) {
   return path.join(memoryDir(cwd), "dream-diary.md");
@@ -1211,7 +1262,7 @@ function entryHash(entry) {
   ).digest("hex");
 }
 
-// src/internal/dreaming-phases.ts
+// src/internal/dreaming/dreaming-phases.ts
 var DEFAULT_DEDUP_THRESHOLD = 0.95;
 var DEFAULT_CLUSTER_THRESHOLD = 0.75;
 async function lightPhase(facts, embedding, threshold = DEFAULT_DEDUP_THRESHOLD) {
@@ -1369,7 +1420,7 @@ function emptyResult(status) {
   };
 }
 
-// src/internal/index-schema.ts
+// src/internal/index/index-schema.ts
 var SCHEMA_STATEMENTS = [
   `CREATE TABLE IF NOT EXISTS files (
      id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -1415,57 +1466,180 @@ var PRAGMA_STATEMENTS = [
   "PRAGMA foreign_keys=ON"
 ];
 
-// src/internal/index-db.ts
+// src/internal/index/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);
+  return persistence.openSqliteResilient({
+    filePath: opts.filePath,
+    label: "memory-index",
+    recoverCorrupt: opts.recoverCorrupt,
+    onOpen: (db) => {
+      for (const pragma of PRAGMA_STATEMENTS) db.exec(pragma);
+      for (const stmt of SCHEMA_STATEMENTS) db.exec(stmt);
     }
-    throw cause;
+  });
+}
+function defaultIndexPath(cwd) {
+  return path.join(cwd, ".theokit", "memory", ".index", "memory.sqlite");
+}
+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;
 }
-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;
+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 } : {}
+  };
 }
-async function loadDriver(filePath) {
+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;
+}
+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/store/session-loader.ts
+async function discoverSessionFiles(cwd) {
+  let entries;
   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 }
-    );
+    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 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");
+function relativeToRoot(root, absolutePath) {
+  if (absolutePath.startsWith(`${root}/`)) return absolutePath.slice(root.length + 1);
+  return absolutePath;
 }
-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 wikiDir(cwd) {
+  return path.join(memoryDir(cwd), "wiki");
 }
-function defaultIndexPath(cwd) {
-  return path.join(cwd, ".theokit", "memory", ".index", "memory.sqlite");
+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;
 }
 function requireLance() {
   try {
@@ -1595,7 +1769,7 @@ function lanceStoragePath(cwd) {
   return path.join(cwd, ".theokit", "memory", "lance");
 }
 
-// src/internal/memory-index.ts
+// src/internal/index/memory-index.ts
 function parseSearchOptions(options = {}) {
   return {
     maxResults: Math.max(1, options.maxResults ?? 10),
@@ -1603,7 +1777,7 @@ function parseSearchOptions(options = {}) {
   };
 }
 
-// src/internal/lance-memory-adapter.ts
+// src/internal/index/lance-memory-adapter.ts
 var DEFAULT_NAMESPACE = "default";
 var EMPTY_SYNC_RESULT = Object.freeze({
   filesScanned: 0,
@@ -1668,7 +1842,7 @@ function translateLanceHit(hit) {
   };
 }
 
-// src/internal/index-manager-dispatch.ts
+// src/internal/index/index-manager-dispatch.ts
 var VALID_BACKENDS = ["sqlite-vec", "lance"];
 function assertValidBackend(backend) {
   if (!VALID_BACKENDS.includes(backend)) {
@@ -1692,68 +1866,6 @@ async function openLanceIndex(opts) {
   });
   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');
@@ -1779,7 +1891,7 @@ function isSqliteVecLoaded(db) {
   }
 }
 
-// src/internal/vec-index.ts
+// src/internal/index/vec-index.ts
 var META_KEY_PROVIDER_ID = "embedding.providerId";
 var META_KEY_MODEL = "embedding.model";
 var META_KEY_DIMENSION = "embedding.dimension";
@@ -1852,31 +1964,8 @@ async function embedMissingChunks(args) {
   }
   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
+// src/internal/index/index-manager.ts
 var IndexManager = class _IndexManager {
   constructor(cwd, db, embedding) {
     this.cwd = cwd;
@@ -2524,6 +2613,7 @@ exports.appendFactToMarkdown = appendFactToMarkdown;
 exports.assertValidBackend = assertValidBackend;
 exports.buildErrorMetadata = buildErrorMetadata;
 exports.chunkMarkdown = chunkMarkdown;
+exports.createCategorizedMemory = createCategorizedMemory;
 exports.createInMemoryMarkdownProvider = createInMemoryMarkdownProvider;
 exports.createMemoryGetTool = createMemoryGetTool;
 exports.createMemorySearchTool = createMemorySearchTool;