@theokit/sdk 4.62.0 → 4.63.1

package/dist/chunk-6RKUO7AW.cjs

@@ -0,0 +1,864 @@
+'use strict';
+
+var chunkKRD3GQAA_cjs = require('./chunk-KRD3GQAA.cjs');
+var chunkV2BOS4WF_cjs = require('./chunk-V2BOS4WF.cjs');
+var chunk5HEG4CQH_cjs = require('./chunk-5HEG4CQH.cjs');
+var chunk5VB22SYX_cjs = require('./chunk-5VB22SYX.cjs');
+var chunkZF2LDKQQ_cjs = require('./chunk-ZF2LDKQQ.cjs');
+var chunkUALX2J2Q_cjs = require('./chunk-UALX2J2Q.cjs');
+var chunk4ZHTIJNE_cjs = require('./chunk-4ZHTIJNE.cjs');
+var chunkXL7Q7HB2_cjs = require('./chunk-XL7Q7HB2.cjs');
+var chunkEG4QM7ZJ_cjs = require('./chunk-EG4QM7ZJ.cjs');
+var os = require('os');
+var path = require('path');
+var promises = require('fs/promises');
+var fs = require('fs');
+var module$1 = require('module');
+var crypto = require('crypto');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+var DEFAULT_SUBPATH = [".theokit", "memory"];
+function asMemoryRoot(dir) {
+  return dir;
+}
+function projectMemoryDir(cwd) {
+  return path.join(cwd, ...DEFAULT_SUBPATH);
+}
+function claudeProjectMemoryDir(cwd) {
+  const home = process.env.CLAUDE_CONFIG_DIR?.trim();
+  const root = home !== void 0 && home.length > 0 ? home : path.join(os.homedir(), ".claude");
+  return path.join(root, "projects", chunk5HEG4CQH_cjs.encodeProjectDir(cwd), "memory");
+}
+function resolveMemoryRoot(cwd, config) {
+  const declared = config?.directory;
+  if (declared === void 0) return projectMemoryDir(cwd);
+  const trimmed = declared.trim();
+  if (trimmed.startsWith("~/")) return path.join(os.homedir(), trimmed.slice(2));
+  if (trimmed.length === 0 || !path.isAbsolute(trimmed)) {
+    throw new chunk4ZHTIJNE_cjs.ConfigurationError(
+      `memory.directory must be an absolute path or start with "~/". Received: ${JSON.stringify(declared)}`,
+      { code: "invalid_memory_directory" }
+    );
+  }
+  return trimmed;
+}
+var MEMORY_INDEX_MAX_LINES = 200;
+var MEMORY_INDEX_MAX_BYTES = 25 * 1024;
+function indexBudgetWarning(index, root) {
+  if (root !== claudeProjectMemoryDirFor(root)) return void 0;
+  const lines = index.split("\n").length;
+  const bytes = Buffer.byteLength(index, "utf8");
+  const over = [];
+  if (lines > MEMORY_INDEX_MAX_LINES) over.push(`${lines} lines (limit ${MEMORY_INDEX_MAX_LINES})`);
+  if (bytes > MEMORY_INDEX_MAX_BYTES) {
+    over.push(`${Math.round(bytes / 1024)} KB (limit ${MEMORY_INDEX_MAX_BYTES / 1024} KB)`);
+  }
+  if (over.length === 0) return void 0;
+  return `MEMORY.md at ${root} is ${over.join(" and ")}. The Claude Code CLI loads only the first ${MEMORY_INDEX_MAX_LINES} lines / ${MEMORY_INDEX_MAX_BYTES / 1024} KB of an index and drops the rest without saying so, which is where this store is written. Shorten the entries or move detail into the per-memory files. Recall through this SDK is unaffected \u2014 it reads the files, not the index.`;
+}
+function claudeProjectMemoryDirFor(root) {
+  const home = process.env.CLAUDE_CONFIG_DIR?.trim();
+  const claudeHome = home !== void 0 && home.length > 0 ? home : path.join(os.homedir(), ".claude");
+  const prefix = path.join(claudeHome, "projects");
+  const isUnderProjects = root.startsWith(`${prefix}${path.sep}`);
+  return isUnderProjects && root.endsWith(`${path.sep}memory`) ? root : "";
+}
+function memoryReadRoots(cwd, config) {
+  return [
+    .../* @__PURE__ */ new Set([
+      resolveMemoryRoot(cwd, config),
+      projectMemoryDir(cwd),
+      claudeProjectMemoryDir(cwd)
+    ])
+  ];
+}
+var MEMORY_KINDS = ["user", "feedback", "project", "reference"];
+function legacyMemoryJsonPath(cwd, config) {
+  if (config.storePath !== void 0) {
+    return path.resolve(cwd, config.storePath);
+  }
+  const namespace = chunkV2BOS4WF_cjs.sanitizeIdentifier(config.namespace ?? "default");
+  const scope = chunkV2BOS4WF_cjs.sanitizeIdentifier(config.scope ?? "agent", { maxLen: 16 });
+  const userId = chunkV2BOS4WF_cjs.sanitizeIdentifier(config.userId ?? "default");
+  return chunkV2BOS4WF_cjs.safePathJoin(cwd, ".theokit", "memory", namespace, `${scope}-${userId}.json`);
+}
+
+// src/internal/memory/storage/memory-file.ts
+var SAFE_SLUG = /^[a-z0-9][a-z0-9_-]*$/;
+var MAX_SLUG_LENGTH = 64;
+var TARGET_SLUG_LENGTH = 32;
+var TITLE_MAX_LENGTH = 40;
+var TITLE_MAX_WORDS = 4;
+var SLUG_STOPWORDS = /* @__PURE__ */ new Set([
+  "the",
+  "a",
+  "an",
+  "and",
+  "or",
+  "but",
+  "is",
+  "are",
+  "was",
+  "were",
+  "be",
+  "been",
+  "being",
+  "for",
+  "of",
+  "to",
+  "in",
+  "on",
+  "at",
+  "by",
+  "with",
+  "from",
+  "as",
+  "that",
+  "this",
+  "these",
+  "those",
+  "it",
+  "its",
+  "he",
+  "she",
+  "they",
+  "we",
+  "you",
+  "i",
+  "do",
+  "does",
+  "did",
+  "has",
+  "have",
+  "had",
+  "will",
+  "would",
+  "can",
+  "could",
+  "should",
+  "must",
+  "not",
+  "no",
+  "over",
+  "under",
+  "into",
+  "onto",
+  "than",
+  "then",
+  "when",
+  "where",
+  "which",
+  "who",
+  "why",
+  "how",
+  "all",
+  "any",
+  "each",
+  "more",
+  "most",
+  "other",
+  "some",
+  "such",
+  "only",
+  "own",
+  "same",
+  "so",
+  "too",
+  "very",
+  "just",
+  "also",
+  "about",
+  "after",
+  "before",
+  "between",
+  "during",
+  "up",
+  "down",
+  "out",
+  "off",
+  "again",
+  "once",
+  "here",
+  "there",
+  "if",
+  "because",
+  "while"
+]);
+function topicWords(text) {
+  return text.toLowerCase().normalize("NFD").replace(/[̀-ͯ]/g, "").split(/[^a-z0-9]+/).filter((w) => w.length >= 2 && !SLUG_STOPWORDS.has(w));
+}
+function slugForFact(text) {
+  const words = topicWords(text);
+  let slug = "";
+  for (const w of words) {
+    const next = slug.length === 0 ? w : `${slug}-${w}`;
+    if (next.length > TARGET_SLUG_LENGTH && slug.length > 0) break;
+    if (next.length > MAX_SLUG_LENGTH) break;
+    slug = next;
+  }
+  if (slug.length === 0) {
+    slug = text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, MAX_SLUG_LENGTH).replace(/-+$/, "");
+  }
+  return SAFE_SLUG.test(slug) ? slug : chunkV2BOS4WF_cjs.safeFilenameForId(text);
+}
+function titleForFact(text) {
+  const words = topicWords(text);
+  if (words.length === 0) return text.trim().slice(0, TITLE_MAX_LENGTH);
+  let title = "";
+  let used = 0;
+  for (const w of words) {
+    if (used >= TITLE_MAX_WORDS) break;
+    const next = title.length === 0 ? w : `${title} ${w}`;
+    if (next.length > TITLE_MAX_LENGTH && title.length > 0) break;
+    title = next;
+    used += 1;
+  }
+  if (title.length === 0) title = words[0];
+  return title.charAt(0).toUpperCase() + title.slice(1);
+}
+function readMetadata(raw) {
+  const metadata = raw ?? {};
+  const rawKind = metadata.type;
+  const kind = typeof rawKind === "string" && MEMORY_KINDS.includes(rawKind) ? rawKind : void 0;
+  const modified = typeof metadata.modified === "string" ? metadata.modified : void 0;
+  const observations = readObservationCount(metadata.observations);
+  return {
+    ...kind !== void 0 ? { kind } : {},
+    ...modified !== void 0 ? { modified } : {},
+    ...observations !== void 0 ? { observations } : {}
+  };
+}
+function readObservationCount(raw) {
+  if (typeof raw !== "number") return void 0;
+  if (!Number.isInteger(raw) || raw <= 0) return void 0;
+  return raw;
+}
+function renderMemoryFile(fields) {
+  const metadata = ["  node_type: memory"];
+  if (fields.kind !== void 0) metadata.push(`  type: ${fields.kind}`);
+  if (fields.modified !== void 0) metadata.push(`  modified: ${fields.modified}`);
+  if (fields.observations !== void 0) {
+    metadata.push(`  observations: ${fields.observations}`);
+  }
+  return [
+    "---",
+    `name: ${fields.name}`,
+    `description: ${JSON.stringify(fields.description)}`,
+    "metadata:",
+    ...metadata,
+    "---",
+    "",
+    fields.body,
+    ""
+  ].join("\n");
+}
+function parseMemoryFile(raw) {
+  const { yaml, body } = chunkKRD3GQAA_cjs.splitFrontmatter(raw);
+  if (yaml === void 0) return void 0;
+  let fields;
+  try {
+    fields = chunkKRD3GQAA_cjs.parseSimpleYaml(yaml);
+  } catch {
+    return void 0;
+  }
+  const name = fields.name;
+  const description = fields.description;
+  if (typeof name !== "string" || typeof description !== "string") return void 0;
+  return {
+    name,
+    description,
+    ...readMetadata(fields.metadata),
+    body: body.trim()
+  };
+}
+
+// src/internal/memory/storage/threat-scan.ts
+var INVISIBLE_CLASS = "\\u200B-\\u200F\\u202A-\\u202E\\u2066-\\u2069\\uFEFF";
+var THREAT_PATTERNS = [
+  {
+    id: "invisible_unicode",
+    // Text that renders as one thing to a reviewer and another to a parser is the whole
+    // technique.
+    test: new RegExp(`[${INVISIBLE_CLASS}]`, "u"),
+    why: "contains invisible or bidirectional control characters"
+  },
+  {
+    id: "instruction_override",
+    // The framing that tries to make recalled text outrank the system prompt. A memory entry
+    // states what was learned; it never addresses the model's instructions.
+    test: /\b(?:ignore|disregard|forget|override)\s+(?:all\s+|any\s+|the\s+|your\s+|previous\s+|prior\s+|earlier\s+|above\s+)*(?:instruction|prompt|rule|directive|guideline|system\s+prompt)/i,
+    why: "addresses the model's instructions instead of stating what was learned"
+  },
+  {
+    id: "role_reassignment",
+    test: /\b(?:you\s+are\s+now|from\s+now\s+on\s+you\s+(?:are|will|must)|new\s+system\s+prompt|act\s+as\s+(?:if\s+you\s+are\s+)?(?:an?\s+)?(?:unrestricted|jailbroken|developer\s+mode))/i,
+    why: "attempts to reassign the agent's role"
+  },
+  // A `pipe_to_shell` pattern (`curl … | sh`) was written here and REMOVED after measurement.
+  // It fired on 1 of 797 real memory files, and the hit was legitimate: a note documenting the
+  // product's own install command in a table. Fetch-and-execute in a hostile entry and in an
+  // install instruction are textually identical, so the pattern cannot be narrowed — only
+  // traded. Rejecting the write would mean the first person to save install docs to memory
+  // gets a hard failure, which buys nothing: an entry the agent READS is not an entry the
+  // agent RUNS, and execution is gated at the tool boundary, where it belongs. Left out on
+  // purpose, so nobody re-adds it without repeating the measurement.
+  {
+    id: "encoded_payload",
+    // A base64 run this long is not prose. Short tokens are left alone precisely so that hashes,
+    // commit SHAs and identifiers keep working.
+    test: /[A-Za-z0-9+/]{256,}={0,2}/,
+    why: "carries a long encoded payload rather than readable text"
+  }
+];
+var EXCERPT_RADIUS = 40;
+var EXCERPT_SCRUB = new RegExp(`[\\u0000-\\u001F${INVISIBLE_CLASS}]`, "gu");
+function scanForThreats(text) {
+  for (const pattern of THREAT_PATTERNS) {
+    const m = pattern.test.exec(text);
+    if (m === null) continue;
+    const at = m.index;
+    const start = Math.max(0, at - EXCERPT_RADIUS);
+    const end = Math.min(text.length, at + m[0].length + EXCERPT_RADIUS);
+    const window = text.slice(start, end).replace(EXCERPT_SCRUB, "\u2423");
+    return {
+      id: pattern.id,
+      why: pattern.why,
+      excerpt: `${start > 0 ? "\u2026" : ""}${window}${end < text.length ? "\u2026" : ""}`
+    };
+  }
+  return void 0;
+}
+THREAT_PATTERNS.map((p) => p.id);
+
+// src/internal/memory/storage/markdown-store.ts
+var MEMORY_MD_HEADER = "# Memory Index\n";
+var FACTS_HEADING = "## Facts";
+var MAX_NAME_VARIANTS = 50;
+function memoryMdPath(root) {
+  return path.join(root, "MEMORY.md");
+}
+function notesDir(root) {
+  return path.join(root, "notes");
+}
+function byNaturalName(a, b) {
+  const split = (f) => {
+    const stem = f.replace(/\.md$/, "");
+    const m = /^(.*?)-(\d+)$/.exec(stem);
+    return m === null ? [stem, 0] : [m[1], Number(m[2])];
+  };
+  const [baseA, nA] = split(a);
+  const [baseB, nB] = split(b);
+  return baseA === baseB ? nA - nB : baseA.localeCompare(baseB);
+}
+async function readFactsFromMarkdown(cwd, config) {
+  const facts = [];
+  const roots = memoryReadRoots(cwd, config);
+  for (const dir of roots) facts.push(...await readMemoryFilesIn(dir));
+  for (const dir of roots) facts.push(...await readLegacyFactsSectionIn(dir));
+  return facts;
+}
+async function readMemoryFilesIn(dir) {
+  let entries;
+  try {
+    entries = await promises.readdir(dir);
+  } catch {
+    return [];
+  }
+  const facts = [];
+  for (const entry of entries.sort(byNaturalName)) {
+    const fact = await readMemoryFileIn(dir, entry);
+    if (fact !== void 0) facts.push(fact);
+  }
+  facts.sort((a, b) => (a.modified ?? "").localeCompare(b.modified ?? ""));
+  return facts;
+}
+async function readLegacyFactsSectionIn(dir) {
+  try {
+    return parseFactsSection(await promises.readFile(path.join(dir, "MEMORY.md"), "utf8"));
+  } catch {
+    return [];
+  }
+}
+async function readMemoryFileIn(dir, entry) {
+  if (!entry.endsWith(".md") || entry === "MEMORY.md") return void 0;
+  let raw;
+  try {
+    raw = await promises.readFile(path.join(dir, entry), "utf8");
+  } catch {
+    return void 0;
+  }
+  const parsed = parseMemoryFile(raw);
+  if (parsed === void 0) return void 0;
+  const body = parsed.body.trim();
+  return {
+    text: body.length > 0 ? body : parsed.description,
+    ...parsed.kind !== void 0 ? { kind: parsed.kind } : {},
+    ...parsed.modified !== void 0 ? { modified: parsed.modified } : {},
+    ...parsed.observations !== void 0 ? { observations: parsed.observations } : {}
+  };
+}
+function assertWritable(fact, text) {
+  if (fact.kind !== void 0 && !MEMORY_KINDS.includes(fact.kind)) {
+    throw new chunk4ZHTIJNE_cjs.ConfigurationError(
+      `Unknown memory fact kind "${fact.kind}". Expected one of: ${MEMORY_KINDS.join(", ")}.`,
+      { code: "invalid_memory_kind" }
+    );
+  }
+  const threat = scanForThreats(text);
+  if (threat !== void 0) {
+    throw new chunk4ZHTIJNE_cjs.ConfigurationError(
+      `Refusing to write a memory entry that ${threat.why}: ${threat.excerpt}`,
+      { code: "memory_threat_rejected" }
+    );
+  }
+}
+function appendFactToMarkdown(cwd, fact, targetDir = projectMemoryDir(cwd)) {
+  return chunkZF2LDKQQ_cjs.withCwdMutex(targetDir, async () => {
+    const text = chunkXL7Q7HB2_cjs.redactSecrets(fact.text);
+    assertWritable(fact, text);
+    const title = fact.title?.trim() ?? titleForFact(text);
+    const base = fact.title !== void 0 ? slugForFact(fact.title) : slugForFact(text);
+    await promises.mkdir(targetDir, { recursive: true });
+    const name = await resolveName(targetDir, base, text);
+    const description = fact.description?.trim() ?? text;
+    const observations = await nextObservationCount(targetDir, name, text);
+    await chunkUALX2J2Q_cjs.replaceFileAtomic(
+      path.join(targetDir, `${name}.md`),
+      renderMemoryFile({
+        name,
+        description,
+        ...fact.kind !== void 0 ? { kind: fact.kind } : {},
+        modified: (/* @__PURE__ */ new Date()).toISOString(),
+        observations,
+        body: text
+      })
+    );
+    const index = await nextIndex(targetDir, description, name, title);
+    await chunkUALX2J2Q_cjs.replaceFileAtomic(path.join(targetDir, "MEMORY.md"), index);
+    const warning = indexBudgetWarning(index, targetDir);
+    if (warning !== void 0) chunkEG4QM7ZJ_cjs.diag(`[theokit-sdk] ${warning}
+`);
+  });
+}
+async function resolveName(dir, base, text) {
+  const wanted = normalizeFactText(text);
+  for (let i = 1; i <= MAX_NAME_VARIANTS; i += 1) {
+    const candidate = i === 1 ? base : `${base}-${i}`;
+    let existing;
+    try {
+      existing = await promises.readFile(path.join(dir, `${candidate}.md`), "utf8");
+    } catch {
+      return candidate;
+    }
+    const parsed = parseMemoryFile(existing);
+    if (parsed === void 0) return candidate;
+    if (normalizeFactText(parsed.body) === wanted) return candidate;
+  }
+  return slugForFact(text) === base ? chunkV2BOS4WF_cjs.safeFilenameForId(text) : slugForFact(text);
+}
+async function nextObservationCount(dir, name, text) {
+  let existing;
+  try {
+    existing = await promises.readFile(path.join(dir, `${name}.md`), "utf8");
+  } catch {
+    return 1;
+  }
+  const parsed = parseMemoryFile(existing);
+  if (parsed === void 0) return 1;
+  const sameFact = normalizeFactText(parsed.body) === normalizeFactText(text);
+  if (!sameFact) return 1;
+  return (parsed.observations ?? 1) + 1;
+}
+function normalizeFactText(text) {
+  return text.trim().toLowerCase().replace(/\s+/g, " ").replace(/[.!?]+$/, "");
+}
+async function nextIndex(dir, text, name, title) {
+  let existing = "";
+  try {
+    existing = await promises.readFile(path.join(dir, "MEMORY.md"), "utf8");
+  } catch {
+    existing = "";
+  }
+  const hook = text.replace(/\s+/g, " ").trim();
+  const entry = hook.length > 0 && hook !== title ? `- [${title}](${name}.md) \u2014 ${hook}` : `- [${title}](${name}.md)`;
+  const kept = existing.split("\n").filter((line) => !line.startsWith(`- [`) || !line.includes(`](${name}.md)`));
+  const body = kept.join("\n").trimEnd();
+  const head = body.length > 0 ? body : MEMORY_MD_HEADER;
+  return `${head}
+${entry}
+`;
+}
+var INDEX_ENTRY = /^\[[^\]]*\]\([^)]+\.md\)(?:\s+—\s.*)?$/;
+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) => line.slice(2).trim()).filter((body) => !INDEX_ENTRY.test(body)).map((body) => ({ text: body }));
+}
+async function readFacts(cwd, config) {
+  if (!config.enabled) return [];
+  return readFactsFromMarkdown(cwd, config);
+}
+async function appendFact(cwd, config, fact) {
+  if (!config.enabled) return;
+  await appendFactToMarkdown(cwd, fact, resolveMemoryRoot(cwd, config));
+}
+var MAX_TURN_CHARS = 2e3;
+function sessionsDir(root) {
+  return path.join(root, "sessions");
+}
+function sessionSummaryPath(root, runId) {
+  return path.join(sessionsDir(root), `${chunkV2BOS4WF_cjs.safeFilenameForId(runId, { maxLen: 128 })}.md`);
+}
+function truncate(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.memoryRoot, input.runId);
+  await promises.mkdir(sessionsDir(input.memoryRoot), { recursive: true });
+  const safeUser = chunkXL7Q7HB2_cjs.redactSecrets(truncate(input.userText));
+  const safeAssistant = chunkXL7Q7HB2_cjs.redactSecrets(truncate(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 chunkUALX2J2Q_cjs.replaceFileAtomic(path, body);
+}
+
+// src/internal/memory/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 PRAGMA_STATEMENTS = [
+  "PRAGMA synchronous=NORMAL",
+  "PRAGMA foreign_keys=ON"
+];
+
+// src/internal/memory/index-db.ts
+async function openMemoryDb(opts) {
+  return chunk5VB22SYX_cjs.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);
+    }
+  });
+}
+function defaultIndexPath(root) {
+  return path.join(root, ".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('chunk-6RKUO7AW.cjs', document.baseURI).href)));
+    return r("@lancedb/lancedb");
+  } catch (cause) {
+    throw new chunk4ZHTIJNE_cjs.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 ?? lanceStoragePath(opts.memoryRoot ?? resolveMemoryRoot(opts.cwd));
+    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 chunk4ZHTIJNE_cjs.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
+   * structured object filter — NEVER string interpolation.
+   */
+  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 chunk4ZHTIJNE_cjs.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 lanceStoragePath(root) {
+  return path.join(root, "lance");
+}
+async function discoverSessionFiles(root) {
+  let entries;
+  try {
+    entries = await promises.readdir(sessionsDir(root));
+  } catch {
+    return [];
+  }
+  return entries.filter((entry) => entry.endsWith(".md")).map((entry) => {
+    const absolutePath = path.join(sessionsDir(root), entry);
+    return {
+      absolutePath,
+      relPath: relativeToRoot(root, absolutePath)
+    };
+  });
+}
+function relativeToRoot(root, absolutePath) {
+  if (absolutePath.startsWith(`${root}/`)) return absolutePath.slice(root.length + 1);
+  return absolutePath;
+}
+function wikiDir(root) {
+  return path.join(root, "wiki");
+}
+async function discoverWikiFiles(root) {
+  let entries;
+  try {
+    entries = await promises.readdir(wikiDir(root));
+  } catch {
+    return [];
+  }
+  return entries.filter((entry) => entry.endsWith(".md")).map((entry) => ({
+    absolutePath: path.join(wikiDir(root), 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 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 markdownFilesIn(dir, root, skip = []) {
+  let entries;
+  try {
+    entries = await promises.readdir(dir);
+  } catch {
+    return [];
+  }
+  return entries.filter((entry) => entry.endsWith(".md") && !skip.includes(entry)).map((entry) => ({
+    absolutePath: path.join(dir, entry),
+    relPath: path.relative(root, path.join(dir, entry)),
+    source: "memory"
+  }));
+}
+async function collectMarkdownFiles(root) {
+  const results = [];
+  try {
+    await promises.stat(memoryMdPath(root));
+    results.push({
+      absolutePath: memoryMdPath(root),
+      relPath: path.relative(root, memoryMdPath(root)),
+      source: "memory"
+    });
+  } catch {
+  }
+  results.push(...await markdownFilesIn(root, root, ["MEMORY.md"]));
+  results.push(...await markdownFilesIn(notesDir(root), root));
+  const wikiFiles = await discoverWikiFiles(root);
+  for (const wiki of wikiFiles) {
+    results.push({
+      absolutePath: wiki.absolutePath,
+      relPath: wiki.relPath,
+      source: "wiki"
+    });
+  }
+  const sessionFiles = await discoverSessionFiles(root);
+  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`;
+}
+
+exports.LanceIndex = LanceIndex;
+exports.MEMORY_INDEX_MAX_BYTES = MEMORY_INDEX_MAX_BYTES;
+exports.MEMORY_INDEX_MAX_LINES = MEMORY_INDEX_MAX_LINES;
+exports.MEMORY_KINDS = MEMORY_KINDS;
+exports.appendFact = appendFact;
+exports.appendFactToMarkdown = appendFactToMarkdown;
+exports.asMemoryRoot = asMemoryRoot;
+exports.blendScores = blendScores;
+exports.claudeProjectMemoryDir = claudeProjectMemoryDir;
+exports.collectMarkdownFiles = collectMarkdownFiles;
+exports.defaultIndexPath = defaultIndexPath;
+exports.discoverSessionFiles = discoverSessionFiles;
+exports.discoverWikiFiles = discoverWikiFiles;
+exports.indexBudgetWarning = indexBudgetWarning;
+exports.lanceStoragePath = lanceStoragePath;
+exports.legacyMemoryJsonPath = legacyMemoryJsonPath;
+exports.memoryMdPath = memoryMdPath;
+exports.memoryReadRoots = memoryReadRoots;
+exports.notesDir = notesDir;
+exports.openMemoryDb = openMemoryDb;
+exports.projectMemoryDir = projectMemoryDir;
+exports.readFacts = readFacts;
+exports.readFactsFromMarkdown = readFactsFromMarkdown;
+exports.resolveMemoryRoot = resolveMemoryRoot;
+exports.resolveWeights = resolveWeights;
+exports.sessionSummaryPath = sessionSummaryPath;
+exports.sessionsDir = sessionsDir;
+exports.sha256 = sha256;
+exports.truncateSnippet = truncateSnippet;
+exports.wikiDir = wikiDir;
+exports.writeSessionSummary = writeSessionSummary;
+//# sourceMappingURL=chunk-6RKUO7AW.cjs.map
+//# sourceMappingURL=chunk-6RKUO7AW.cjs.map