@remnic/core 1.0.0

package/dist/index.js

@@ -0,0 +1,2512 @@
+import {
+  generateToken,
+  getAllValidTokens,
+  getAllValidTokensCached,
+  listTokens,
+  loadTokenStore,
+  resolveConnectorFromToken,
+  revokeToken,
+  saveTokenStore
+} from "./chunk-KL4CP4SB.js";
+import {
+  Orchestrator,
+  defaultWorkspaceDir,
+  migrateFromEngram,
+  rollbackFromEngramMigration,
+  sanitizeSessionKeyForFilename
+} from "./chunk-YAPUAHAY.js";
+import "./chunk-IFFFR3MR.js";
+import "./chunk-TKO4HZCK.js";
+import "./chunk-Z5AAYHUC.js";
+import "./chunk-4A24LIM2.js";
+import "./chunk-TPB3I2AC.js";
+import "./chunk-UHGBNIOS.js";
+import "./chunk-ZKYI7UVO.js";
+import "./chunk-CDW777AI.js";
+import "./chunk-ETOW6ACV.js";
+import "./chunk-G3AG3KZN.js";
+import "./chunk-2CJCWDMR.js";
+import "./chunk-X7XN6YU4.js";
+import "./chunk-BRK4ODMI.js";
+import "./chunk-C7VW7C3F.js";
+import "./chunk-GPGBSNKM.js";
+import "./chunk-V3RXWQIE.js";
+import "./chunk-YCN4BVDK.js";
+import "./chunk-L5RPWGFK.js";
+import "./chunk-HG2NKWR2.js";
+import "./chunk-GJR6D6KC.js";
+import "./chunk-H63EDPFJ.js";
+import "./chunk-WWIQTB2Y.js";
+import {
+  ExtractionEngine
+} from "./chunk-QFQVZOGA.js";
+import "./chunk-MWGVGUIS.js";
+import "./chunk-763GUIOU.js";
+import "./chunk-ONRU4L2N.js";
+import "./chunk-MDDAA2AO.js";
+import "./chunk-YAZNBMNF.js";
+import {
+  loadDaySummaryPrompt
+} from "./chunk-2PO5ZRKV.js";
+import "./chunk-VEWZZM3H.js";
+import "./chunk-QPKFPHOO.js";
+import {
+  buildEntityRecallSection
+} from "./chunk-V4YC4LUK.js";
+import "./chunk-HLBYLYRD.js";
+import "./chunk-OTAVQCSF.js";
+import "./chunk-3QKK7QOS.js";
+import "./chunk-UIYZ5T3I.js";
+import "./chunk-UCYSTFZR.js";
+import "./chunk-J47FNDR7.js";
+import "./chunk-CULXMQJH.js";
+import "./chunk-UV2FO7J4.js";
+import "./chunk-T4WRIV2C.js";
+import "./chunk-LOBRX7VD.js";
+import {
+  LanceDbBackend,
+  MeilisearchBackend,
+  OramaBackend
+} from "./chunk-IZME7KW2.js";
+import "./chunk-YRMVARQP.js";
+import {
+  QmdClient
+} from "./chunk-TVVVQQAK.js";
+import "./chunk-BDFZXRSO.js";
+import "./chunk-LK6SGL53.js";
+import "./chunk-AAI7JARD.js";
+import "./chunk-C6QPK5GG.js";
+import "./chunk-Q6FETXJA.js";
+import "./chunk-K6WK37A6.js";
+import "./chunk-SCHEKPYH.js";
+import "./chunk-ORZMT74A.js";
+import "./chunk-B7LOFDVE.js";
+import "./chunk-FYIYMQ5N.js";
+import "./chunk-2NMMFZ5T.js";
+import {
+  parseConfig
+} from "./chunk-ISY75RLM.js";
+import "./chunk-Z5LAYHGJ.js";
+import "./chunk-JWPLJLDU.js";
+import {
+  BootstrapEngine
+} from "./chunk-YNI4S5WT.js";
+import "./chunk-DORBM6OB.js";
+import "./chunk-XYIK4LF6.js";
+import "./chunk-KT4NEUNF.js";
+import "./chunk-LU3GQNDQ.js";
+import "./chunk-Y27UJK6V.js";
+import "./chunk-UZB5KHKX.js";
+import "./chunk-M5KEYE5E.js";
+import "./chunk-NGAVDO7E.js";
+import {
+  EngramAccessHttpServer
+} from "./chunk-ZJLY4QSU.js";
+import {
+  EngramMcpServer
+} from "./chunk-CXWFUJR2.js";
+import "./chunk-MARWOCVP.js";
+import {
+  formatZodError,
+  memoryStoreRequestSchema,
+  observeRequestSchema,
+  recallRequestSchema,
+  suggestionSubmitRequestSchema,
+  validateRequest
+} from "./chunk-PGK3VUHN.js";
+import {
+  EngramAccessInputError,
+  EngramAccessService
+} from "./chunk-QY2BHY5O.js";
+import "./chunk-N5AKDXAI.js";
+import {
+  isTrustZoneName
+} from "./chunk-EQINRHYR.js";
+import "./chunk-J3BT33K7.js";
+import "./chunk-EEQLFRUM.js";
+import {
+  StorageManager
+} from "./chunk-QWUUMMIK.js";
+import "./chunk-U4PV25RD.js";
+import "./chunk-ESSMF2FR.js";
+import "./chunk-TP4FZJIZ.js";
+import "./chunk-SCU65EZI.js";
+import "./chunk-BOUYNNYD.js";
+import "./chunk-DM2T26WE.js";
+import "./chunk-QSVPYQPG.js";
+import "./chunk-YNCQ7E4M.js";
+import "./chunk-HLXVTBF3.js";
+import "./chunk-M62O4P4T.js";
+import "./chunk-DT5TVLJE.js";
+import {
+  initLogger,
+  log
+} from "./chunk-KWBU5S5U.js";
+import "./chunk-DGXUHMOV.js";
+import "./chunk-LPSF4OQH.js";
+import "./chunk-XKECPATV.js";
+import "./chunk-6HZ6AO2P.js";
+import "./chunk-QCCCQT3O.js";
+
+// src/projection/index.ts
+import fs from "fs";
+import path2 from "path";
+
+// src/utils/category-dir.ts
+import path from "path";
+var CATEGORY_DIR_MAP = {
+  correction: "corrections",
+  question: "questions",
+  preference: "preferences",
+  decision: "decisions",
+  moment: "moments",
+  commitment: "commitments",
+  principle: "principles",
+  rule: "rules",
+  skill: "skills",
+  relationship: "relationships"
+};
+var ALL_CATEGORY_DIRS = [
+  "facts",
+  ...Object.values(CATEGORY_DIR_MAP)
+];
+var ALL_CATEGORY_KEYS = [
+  "fact",
+  ...Object.keys(CATEGORY_DIR_MAP)
+];
+function getCategoryDir(memoryDir, category) {
+  const dir = CATEGORY_DIR_MAP[category];
+  return dir ? path.join(memoryDir, dir) : path.join(memoryDir, "facts");
+}
+
+// src/projection/index.ts
+async function generateContextTree(options) {
+  const startTime = Date.now();
+  const {
+    memoryDir,
+    outputDir,
+    categories: filterCategories,
+    includeEntities = true,
+    includeQuestions = true,
+    maxPerCategory = Infinity
+  } = options;
+  let nodesGenerated = 0;
+  let nodesSkipped = 0;
+  const categoryCounts = {};
+  fs.mkdirSync(outputDir, { recursive: true });
+  const allCategories = filterCategories ?? ALL_CATEGORY_KEYS.filter((c) => c !== "question");
+  for (const category of allCategories) {
+    const categoryDir = getCategoryDir(memoryDir, category);
+    if (!fs.existsSync(categoryDir)) continue;
+    categoryCounts[category] = 0;
+    const files = walkR(categoryDir);
+    let count = 0;
+    for (const filePath of files) {
+      if (count >= maxPerCategory) {
+        nodesSkipped++;
+        continue;
+      }
+      const content = fs.readFileSync(filePath, "utf8");
+      const fm = parseFrontmatter(content);
+      if (!fm) {
+        nodesSkipped++;
+        continue;
+      }
+      const node = projectNode(filePath, category, fm, content);
+      if (!node) {
+        nodesSkipped++;
+        continue;
+      }
+      const outputPath = path2.join(outputDir, node.path);
+      fs.mkdirSync(path2.dirname(outputPath), { recursive: true });
+      fs.writeFileSync(outputPath, node.content);
+      nodesGenerated++;
+      categoryCounts[category] = (categoryCounts[category] ?? 0) + 1;
+      count++;
+    }
+  }
+  if (includeEntities) {
+    const entitiesDir = path2.join(memoryDir, "entities");
+    if (fs.existsSync(entitiesDir)) {
+      categoryCounts["entity"] = 0;
+      const entityFiles = walkR(entitiesDir);
+      let count = 0;
+      for (const filePath of entityFiles) {
+        if (count >= maxPerCategory) {
+          nodesSkipped++;
+          continue;
+        }
+        const content = fs.readFileSync(filePath, "utf8");
+        const fileName = path2.basename(filePath, ".md");
+        const node = projectEntityNode(fileName, content);
+        const outputPath = path2.join(outputDir, "entities", `${fileName}.md`);
+        fs.mkdirSync(path2.dirname(outputPath), { recursive: true });
+        fs.writeFileSync(outputPath, node.content);
+        nodesGenerated++;
+        categoryCounts["entity"] = (categoryCounts["entity"] ?? 0) + 1;
+        count++;
+      }
+    }
+  }
+  if (includeQuestions) {
+    const questionsDir = path2.join(memoryDir, "questions");
+    if (fs.existsSync(questionsDir)) {
+      categoryCounts["question"] = 0;
+      const qFiles = walkR(questionsDir);
+      let count = 0;
+      for (const filePath of qFiles) {
+        if (count >= maxPerCategory) {
+          nodesSkipped++;
+          continue;
+        }
+        const content = fs.readFileSync(filePath, "utf8");
+        const fm = parseFrontmatter(content);
+        if (!fm) {
+          nodesSkipped++;
+          continue;
+        }
+        const node = projectNode(filePath, "question", fm, content);
+        if (!node) {
+          nodesSkipped++;
+          continue;
+        }
+        const outputPath = path2.join(outputDir, node.path);
+        fs.mkdirSync(path2.dirname(outputPath), { recursive: true });
+        fs.writeFileSync(outputPath, node.content);
+        nodesGenerated++;
+        categoryCounts["question"] = (categoryCounts["question"] ?? 0) + 1;
+        count++;
+      }
+    }
+  }
+  const index = generateIndex(categoryCounts, outputDir);
+  fs.writeFileSync(path2.join(outputDir, "INDEX.md"), index);
+  return {
+    nodesGenerated,
+    nodesSkipped,
+    categories: categoryCounts,
+    durationMs: Date.now() - startTime,
+    outputDir
+  };
+}
+function walkR(dir) {
+  const results = [];
+  function walk(directory) {
+    for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
+      const fullPath = path2.join(directory, entry.name);
+      if (entry.isDirectory()) {
+        walk(fullPath);
+      } else if (entry.name.endsWith(".md")) {
+        results.push(fullPath);
+      }
+    }
+  }
+  walk(dir);
+  return results;
+}
+function parseFrontmatter(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return null;
+  const fmText = match[1];
+  const fm = {};
+  for (const line of fmText.split("\n")) {
+    const colonIdx = line.indexOf(":");
+    if (colonIdx === -1) continue;
+    const key = line.slice(0, colonIdx).trim();
+    const value = line.slice(colonIdx + 1).trim();
+    if (key === "tags") {
+      try {
+        fm[key] = JSON.parse(value);
+      } catch {
+        fm[key] = [];
+      }
+    } else if (key === "confidence") {
+      const parsed = parseFloat(value);
+      fm[key] = Number.isFinite(parsed) ? parsed : 0;
+    } else {
+      fm[key] = value;
+    }
+  }
+  return fm;
+}
+function extractBody(content) {
+  const match = content.match(/^---\n[\s\S]*?\n---\n([\s\S]*)/);
+  return match ? match[1].trim() : content.trim();
+}
+function projectNode(filePath, category, fm, rawContent) {
+  const body = extractBody(rawContent);
+  const fileName = path2.basename(filePath, ".md");
+  const dateDir = path2.basename(path2.dirname(filePath));
+  let relPath;
+  if (/^\d{4}-\d{2}-\d{2}$/.test(dateDir)) {
+    relPath = path2.join(category, dateDir, `${fileName}.md`);
+  } else {
+    relPath = path2.join(category, `${fileName}.md`);
+  }
+  const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const md = `# ${fm.id}
+
+> **Category:** ${fm.category}
+> **Created:** ${fm.created}
+> **Updated:** ${fm.updated ?? fm.created}
+> **Confidence:** ${fm.confidence} (${fm.confidenceTier}${fm.lifecycleState ? `, ${fm.lifecycleState}` : ""})
+${fm.tags?.length ? `
+> **Tags:** ${fm.tags.join(", ")}` : ""}
+${fm.entityRef ? `
+> **Entity:** ${fm.entityRef}` : ""}
+> **Source:** ${fm.source ?? "unknown"}
+> **Projected:** ${generatedAt}
+
+---
+
+${body}
+`;
+  return {
+    path: relPath,
+    category,
+    title: fm.id,
+    content: md,
+    sourceAnchors: [fm.id],
+    confidence: fm.confidence ?? 0,
+    confidenceTier: fm.confidenceTier ?? "unknown",
+    generatedAt,
+    provenance: [{
+      memoryId: fm.id,
+      source: fm.source ?? "unknown",
+      extracted: fm.created
+    }]
+  };
+}
+function projectEntityNode(fileName, content) {
+  const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const md = `> **Projected:** ${generatedAt}
+> **Source:** canonical
+
+---
+
+${content}
+`;
+  return {
+    path: path2.join("entities", `${fileName}.md`),
+    category: "entity",
+    title: fileName,
+    content: md,
+    sourceAnchors: [fileName],
+    confidence: 1,
+    confidenceTier: "explicit",
+    generatedAt,
+    provenance: [{
+      memoryId: fileName,
+      source: "canonical",
+      extracted: generatedAt
+    }]
+  };
+}
+function generateIndex(categoryCounts, outputDir) {
+  const lines = [
+    "# Context Tree Index",
+    "",
+    `Generated: ${(/* @__PURE__ */ new Date()).toISOString()}`,
+    "",
+    "## Summary",
+    "",
+    `| Category | Count |`,
+    `|----------|-------|`
+  ];
+  let total = 0;
+  for (const [cat, count] of Object.entries(categoryCounts).sort()) {
+    lines.push(`| ${cat} | ${count} |`);
+    total += count;
+  }
+  lines.push("");
+  lines.push(`**Total:** ${total} nodes`);
+  lines.push("");
+  lines.push("## Structure");
+  lines.push("");
+  lines.push("```");
+  lines.push("context-tree/");
+  lines.push("\u251C\u2500\u2500 entities/       # Entity knowledge graph");
+  lines.push("\u251C\u2500\u2500 fact/           # Factual memories (date-partitioned)");
+  lines.push("\u251C\u2500\u2500 correction/    # Correction memories");
+  lines.push("\u251C\u2500\u2500 decision/      # Decisions");
+  lines.push("\u251C\u2500\u2500 moment/        # Notable moments");
+  lines.push("\u251C\u2500\u2500 preference/    # Preferences");
+  lines.push("\u251C\u2500\u2500 principle/     # Principles");
+  lines.push("\u251C\u2500\u2500 question/      # Open questions");
+  lines.push("\u2514\u2500\u2500 INDEX.md        # This file");
+  lines.push("```");
+  return lines.join("\n") + "\n";
+}
+
+// src/onboarding/index.ts
+import fs2 from "fs";
+import path3 from "path";
+var LANGUAGE_RULES = [
+  {
+    language: "TypeScript",
+    extensions: [".ts", ".tsx"],
+    manifests: ["package.json"],
+    configFiles: ["tsconfig.json", "tsup.config.ts"]
+  },
+  {
+    language: "JavaScript",
+    extensions: [".js", ".jsx", ".mjs", ".cjs"],
+    manifests: ["package.json"],
+    configFiles: [".eslintrc", ".prettierrc"]
+  },
+  {
+    language: "Python",
+    extensions: [".py", ".pyi"],
+    manifests: ["pyproject.toml", "setup.py", "setup.cfg", "requirements.txt"],
+    configFiles: ["mypy.ini", ".flake8", "tox.ini"]
+  },
+  {
+    language: "Go",
+    extensions: [".go"],
+    manifests: ["go.mod", "go.sum"],
+    configFiles: []
+  },
+  {
+    language: "Rust",
+    extensions: [".rs"],
+    manifests: ["Cargo.toml"],
+    configFiles: []
+  },
+  {
+    language: "Ruby",
+    extensions: [".rb"],
+    manifests: ["Gemfile", "*.gemspec"],
+    configFiles: [".rubocop.yml"]
+  },
+  {
+    language: "PHP",
+    extensions: [".php"],
+    manifests: ["composer.json"],
+    configFiles: ["phpcs.xml"]
+  },
+  {
+    language: "Java",
+    extensions: [".java", ".kt"],
+    manifests: ["pom.xml", "build.gradle", "build.gradle.kts"],
+    configFiles: []
+  },
+  {
+    language: "Swift",
+    extensions: [".swift"],
+    manifests: ["Package.swift", "Podfile"],
+    configFiles: []
+  },
+  {
+    language: "C#",
+    extensions: [".cs"],
+    manifests: ["*.csproj", "*.sln"],
+    configFiles: []
+  },
+  {
+    language: "Shell",
+    extensions: [".sh", ".bash", ".zsh"],
+    manifests: [],
+    configFiles: []
+  },
+  {
+    language: "Dart",
+    extensions: [".dart"],
+    manifests: ["pubspec.yaml"],
+    configFiles: []
+  },
+  {
+    language: "Elixir",
+    extensions: [".ex", ".exs"],
+    manifests: ["mix.exs"],
+    configFiles: []
+  }
+];
+var DEFAULT_EXCLUDE = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "vendor",
+  "__pycache__",
+  ".venv",
+  "venv",
+  "dist",
+  "build",
+  ".next",
+  ".nuxt",
+  "target",
+  "coverage",
+  ".engram"
+]);
+function onboard(options) {
+  const startTime = Date.now();
+  const {
+    directory,
+    maxDepth = 6,
+    excludeDirs = []
+  } = options;
+  const exclude = /* @__PURE__ */ new Set([...DEFAULT_EXCLUDE, ...excludeDirs]);
+  const files = walkDir(directory, exclude, maxDepth);
+  const languages = detectLanguages(files, directory);
+  const { shape, evidence: shapeEvidence } = detectShape(files, directory);
+  const docs = discoverDocs(files, directory);
+  const plan = buildPlan(languages, shape, docs, directory);
+  return {
+    directory,
+    languages,
+    shape,
+    shapeEvidence,
+    docs,
+    totalFiles: files.length,
+    durationMs: Date.now() - startTime,
+    plan
+  };
+}
+function walkDir(root, exclude, maxDepth) {
+  const results = [];
+  function walk(dir, depth) {
+    if (depth > maxDepth) return;
+    let entries;
+    try {
+      entries = fs2.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (exclude.has(entry.name)) continue;
+      const fullPath = path3.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        walk(fullPath, depth + 1);
+      } else if (entry.isFile()) {
+        results.push(fullPath);
+      }
+    }
+  }
+  walk(root, 0);
+  return results;
+}
+function detectLanguages(files, root) {
+  const results = [];
+  const extCounts = /* @__PURE__ */ new Map();
+  for (const f of files) {
+    const ext = path3.extname(f).toLowerCase();
+    if (ext) extCounts.set(ext, (extCounts.get(ext) ?? 0) + 1);
+  }
+  const rootFiles = new Set(
+    files.filter((f) => path3.dirname(f) === root).map((f) => path3.basename(f))
+  );
+  for (const rule of LANGUAGE_RULES) {
+    const evidence = [];
+    let score = 0;
+    let extMatch = 0;
+    for (const ext of rule.extensions) {
+      const count = extCounts.get(ext) ?? 0;
+      if (count > 0) {
+        extMatch += count;
+        evidence.push(`${ext} files (${count})`);
+      }
+    }
+    score += Math.min(extMatch * 0.05, 0.5);
+    for (const manifest of rule.manifests) {
+      if (manifest.includes("*")) {
+        const suffix = manifest.replaceAll(/\*/g, "");
+        if ([...rootFiles].some((f) => f.endsWith(suffix))) {
+          score += 0.2;
+          evidence.push(manifest);
+        }
+      } else if (rootFiles.has(manifest)) {
+        score += 0.2;
+        evidence.push(manifest);
+      }
+    }
+    for (const cfg of rule.configFiles) {
+      if (rootFiles.has(cfg)) {
+        score += 0.1;
+        evidence.push(cfg);
+      }
+    }
+    if (score > 0) {
+      results.push({
+        language: rule.language,
+        confidence: Math.min(score, 1),
+        evidence
+      });
+    }
+  }
+  return results.sort((a, b) => b.confidence - a.confidence);
+}
+function detectShape(files, root) {
+  const rootFiles = new Set(
+    files.filter((f) => path3.dirname(f) === root).map((f) => path3.basename(f))
+  );
+  const rootDirs = /* @__PURE__ */ new Set();
+  try {
+    for (const entry of fs2.readdirSync(root, { withFileTypes: true })) {
+      if (entry.isDirectory()) rootDirs.add(entry.name);
+    }
+  } catch {
+  }
+  const evidence = [];
+  if (rootFiles.has("package.json")) {
+    const pkg = readJsonSafe(path3.join(root, "package.json"));
+    if (pkg?.workspaces) {
+      evidence.push("package.json has workspaces");
+      return { shape: "monorepo", evidence };
+    }
+  }
+  if (rootDirs.has("packages") || rootDirs.has("libs")) {
+    evidence.push("has packages/ or libs/ directory");
+    return { shape: "monorepo", evidence };
+  }
+  if (rootFiles.has("pnpm-workspace.yaml") || rootFiles.has("go.work")) {
+    evidence.push("workspace manifest found");
+    return { shape: "workspace", evidence };
+  }
+  const cargoToml = readTomlWorkspace(path3.join(root, "Cargo.toml"));
+  if (cargoToml) {
+    evidence.push("Cargo.toml has workspace");
+    return { shape: "workspace", evidence };
+  }
+  if (rootFiles.has("package.json")) {
+    const pkg = readJsonSafe(path3.join(root, "package.json"));
+    if (pkg?.exports || pkg?.main) {
+      if (pkg?.bin) {
+        evidence.push("package.json has bin");
+        return { shape: "app", evidence };
+      }
+      evidence.push("package.json has exports/main");
+      return { shape: "library", evidence };
+    }
+  }
+  if (rootFiles.has("Dockerfile") || rootFiles.has("docker-compose.yml") || rootFiles.has("docker-compose.yaml") || rootDirs.has("app") || rootDirs.has("src") && rootDirs.has("public")) {
+    evidence.push("app-like structure detected");
+    return { shape: "app", evidence };
+  }
+  if (files.length <= 5 && !rootFiles.has("package.json") && !rootFiles.has("pyproject.toml")) {
+    evidence.push("few files, no manifest");
+    return { shape: "script", evidence };
+  }
+  return { shape: "unknown", evidence: ["no strong shape signal"] };
+}
+function discoverDocs(files, root) {
+  const docs = [];
+  const docPatterns = [
+    { pattern: /^readme(\.\w+)?$/i, kind: "readme" },
+    { pattern: /^changelog(\.\w+)?$/i, kind: "changelog" },
+    { pattern: /^changes(\.\w+)?$/i, kind: "changelog" },
+    { pattern: /^contributing(\.\w+)?$/i, kind: "contributing" },
+    { pattern: /^code[_-]of[_-]conduct(\.\w+)?$/i, kind: "contributing" },
+    { pattern: /^license(\.\w+)?$/i, kind: "license" },
+    { pattern: /^copying(\.\w+)?$/i, kind: "license" },
+    { pattern: /^\.env\.example$/i, kind: "config" },
+    { pattern: /^\.editorconfig$/i, kind: "config" }
+  ];
+  for (const filePath of files) {
+    const basename = path3.basename(filePath).toLowerCase();
+    const relPath = path3.relative(root, filePath);
+    let kind;
+    for (const { pattern, kind: k } of docPatterns) {
+      if (pattern.test(basename)) {
+        kind = k;
+        break;
+      }
+    }
+    if (!kind && isUnderDocsDir(relPath)) {
+      kind = "docs";
+    }
+    if (!kind && (basename.endsWith(".md") || basename.endsWith(".mdx"))) {
+      if (path3.dirname(relPath) === "." || isUnderDocsDir(relPath)) {
+        kind = "docs";
+      }
+    }
+    if (kind) {
+      let size = 0;
+      try {
+        size = fs2.statSync(filePath).size;
+      } catch {
+      }
+      docs.push({
+        path: filePath,
+        relativePath: relPath,
+        kind,
+        size
+      });
+    }
+  }
+  return docs;
+}
+function isUnderDocsDir(relPath) {
+  const parts = relPath.split(path3.sep);
+  return parts[0] === "docs" || parts[0] === "doc" || parts[0] === "documentation";
+}
+function buildPlan(languages, shape, docs, _root) {
+  const priorityOrder = {
+    readme: 0,
+    contributing: 1,
+    changelog: 2,
+    license: 3,
+    docs: 4,
+    config: 5,
+    other: 6
+  };
+  const priorityFiles = [...docs].filter((d) => d.size > 0).sort((a, b) => priorityOrder[a.kind] - priorityOrder[b.kind]);
+  const categories = ["fact", "preference", "decision", "principle"];
+  if (shape === "monorepo" || shape === "workspace") {
+    categories.push("entity");
+  }
+  const suggestedNamespace = languages.length > 0 ? languages[0].language.toLowerCase() : "project";
+  return {
+    priorityFiles,
+    estimatedFiles: docs.filter((d) => d.size > 0).length,
+    categories,
+    suggestedNamespace
+  };
+}
+function readJsonSafe(filePath) {
+  try {
+    return JSON.parse(fs2.readFileSync(filePath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function readTomlWorkspace(filePath) {
+  try {
+    const content = fs2.readFileSync(filePath, "utf8");
+    return content.includes("[workspace]");
+  } catch {
+    return false;
+  }
+}
+
+// src/curation/index.ts
+import fs3 from "fs";
+import path4 from "path";
+import crypto from "crypto";
+async function curate(options) {
+  const startTime = Date.now();
+  const {
+    targetPath,
+    memoryDir,
+    source = "curation",
+    category: categoryOverride,
+    confidence = 0.9,
+    entityRef,
+    tags = [],
+    checkDuplicates = true,
+    checkContradictions = false,
+    write = true
+  } = options;
+  const statements = [];
+  const written = [];
+  const duplicates = [];
+  const contradictions = [];
+  let filesProcessed = 0;
+  let filesSkipped = 0;
+  const targets = resolveTargets(targetPath);
+  const existingMemories = checkDuplicates || checkContradictions ? loadExistingMemories(memoryDir) : /* @__PURE__ */ new Map();
+  for (const filePath of targets) {
+    const content = readFileSafe(filePath);
+    if (!content) {
+      filesSkipped++;
+      continue;
+    }
+    if (isBinary(content)) {
+      filesSkipped++;
+      continue;
+    }
+    filesProcessed++;
+    const sourceFileHash = hashContent(content);
+    const fileStatements = extractStatements(
+      content,
+      filePath,
+      targetPath,
+      source,
+      sourceFileHash,
+      categoryOverride,
+      confidence,
+      entityRef,
+      tags
+    );
+    for (const stmt of fileStatements) {
+      if (checkDuplicates) {
+        const dup = findDuplicate(stmt, existingMemories);
+        if (dup) {
+          duplicates.push(dup);
+          if (dup.action === "skip") continue;
+        }
+      }
+      if (checkContradictions) {
+        const contra = findContradiction(stmt, existingMemories);
+        if (contra) {
+          contradictions.push(contra);
+        }
+      }
+      statements.push(stmt);
+      if (write) {
+        const writtenPath = writeStatement(stmt, memoryDir);
+        if (writtenPath) {
+          written.push(writtenPath);
+          existingMemories.set(stmt.contentHash, {
+            id: stmt.id,
+            content: stmt.content,
+            category: stmt.category
+          });
+        }
+      }
+    }
+  }
+  return {
+    statements,
+    filesProcessed,
+    filesSkipped,
+    duplicates,
+    contradictions,
+    written,
+    durationMs: Date.now() - startTime
+  };
+}
+function resolveTargets(targetPath) {
+  const stat = fs3.statSync(targetPath);
+  if (stat.isFile()) return [targetPath];
+  const results = [];
+  const extensions = /* @__PURE__ */ new Set([".md", ".txt", ".mdx", ".rst"]);
+  function walk(dir) {
+    for (const entry of fs3.readdirSync(dir, { withFileTypes: true })) {
+      const fullPath = path4.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (entry.name !== "node_modules" && entry.name !== ".git") {
+          walk(fullPath);
+        }
+      } else if (extensions.has(path4.extname(entry.name).toLowerCase())) {
+        results.push(fullPath);
+      }
+    }
+  }
+  walk(targetPath);
+  return results;
+}
+function extractStatements(content, filePath, projectRoot, source, sourceFileHash, categoryOverride, confidence, entityRef, tags) {
+  const relativePath = path4.relative(projectRoot, filePath);
+  const statements = [];
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const paragraphs = content.split(/\n{2,}/).map((p) => p.trim()).filter((p) => p.length > 20 && p.length < 2e3);
+  const listItems = content.split("\n").filter((l) => /^\s*[-*]\s+/.test(l)).map((l) => l.replace(/^\s*[-*]\s+/, "").trim()).filter((l) => l.length > 10 && l.length < 500);
+  const allItems = [...paragraphs, ...listItems];
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of allItems) {
+    const hash = hashContent(item.toLowerCase());
+    if (seen.has(hash)) continue;
+    seen.add(hash);
+    const id = generateId();
+    const category = categoryOverride ?? detectCategory(item);
+    statements.push({
+      id,
+      content: item,
+      category,
+      confidence,
+      provenance: {
+        sourcePath: filePath,
+        relativePath,
+        source,
+        lineNumber: 0,
+        ingestedAt: now,
+        sourceFileHash
+      },
+      contentHash: hash,
+      tags: [...tags],
+      entityRef
+    });
+  }
+  return statements;
+}
+function detectCategory(text) {
+  const lower = text.toLowerCase();
+  if (/^(always|never|must|should|don't|avoid|ensure)/.test(lower)) return "principle";
+  if (/^(we|team|project)\s+(decided|chose|will|use)/.test(lower)) return "decision";
+  if (/^(i|we)\s+(prefer|like|want|hate|dislike)/.test(lower)) return "preference";
+  if (/fix|bug|issue|broken|error/i.test(lower)) return "correction";
+  if (/\?.+$/.test(lower.trim())) return "question";
+  return "fact";
+}
+function findDuplicate(stmt, existing) {
+  const stmtLower = stmt.content.toLowerCase();
+  const exactMatch = existing.get(stmt.contentHash);
+  if (exactMatch) {
+    return {
+      newStatement: stmt,
+      existingId: exactMatch.id,
+      similarity: 1,
+      action: "skip"
+    };
+  }
+  for (const [_, mem] of existing) {
+    const memLower = mem.content.toLowerCase();
+    if (memLower.length > 50 && stmtLower.length > 50) {
+      if (memLower.includes(stmtLower.slice(0, 40)) || stmtLower.includes(memLower.slice(0, 40))) {
+        return {
+          newStatement: stmt,
+          existingId: mem.id,
+          similarity: 0.85,
+          action: "skip"
+        };
+      }
+    }
+  }
+  return null;
+}
+function findContradiction(stmt, existing) {
+  const negationPatterns = [
+    /\b(not|don't|doesn't|isn't|aren't|won't|can't|never|no)\b/i
+  ];
+  const hasNegation = negationPatterns.some((p) => p.test(stmt.content));
+  if (!hasNegation) return null;
+  const stripped = stmt.content.toLowerCase().replace(/\b(not|don't|doesn't|isn't|aren't|won't|can't|never|no)\b/gi, "").trim();
+  if (stripped.length < 20) return null;
+  for (const [_, mem] of existing) {
+    const memLower = mem.content.toLowerCase();
+    if (memLower.includes(stripped.slice(0, Math.min(30, stripped.length)))) {
+      return {
+        newStatement: stmt,
+        conflictingId: mem.id,
+        conflictingContent: mem.content,
+        severity: "high"
+      };
+    }
+  }
+  return null;
+}
+function loadExistingMemories(memoryDir) {
+  const result = /* @__PURE__ */ new Map();
+  if (!fs3.existsSync(memoryDir)) return result;
+  const dirs = ALL_CATEGORY_DIRS;
+  for (const dir of dirs) {
+    const fullDir = path4.join(memoryDir, dir);
+    if (!fs3.existsSync(fullDir)) continue;
+    walkFiles(fullDir, (filePath) => {
+      const content = readFileSafe(filePath);
+      if (!content) return;
+      const fm = parseFrontmatter2(content);
+      const body = extractBody2(content);
+      if (!fm?.id || !body) return;
+      const hash = hashContent(body.toLowerCase());
+      result.set(hash, {
+        id: fm.id,
+        content: body,
+        category: fm.category ?? dir.slice(0, -1)
+      });
+    });
+  }
+  return result;
+}
+function writeStatement(stmt, memoryDir) {
+  const now = /* @__PURE__ */ new Date();
+  const dateDir = now.toISOString().split("T")[0];
+  const categoryDir = getCategoryDir(memoryDir, stmt.category);
+  const dir = path4.join(categoryDir, dateDir);
+  fs3.mkdirSync(dir, { recursive: true });
+  const fileName = `${stmt.category}-${Date.now()}-${stmt.id.slice(0, 8)}.md`;
+  const filePath = path4.join(dir, fileName);
+  const frontmatter = [
+    "---",
+    `id: ${stmt.id}`,
+    `category: ${stmt.category}`,
+    `created: ${stmt.provenance.ingestedAt}`,
+    `updated: ${stmt.provenance.ingestedAt}`,
+    `confidence: ${stmt.confidence}`,
+    `confidenceTier: ${tierFromConfidence(stmt.confidence)}`,
+    `source: ${stmt.provenance.source}`,
+    `tags: ${JSON.stringify(stmt.tags)}`,
+    stmt.entityRef ? `entityRef: ${stmt.entityRef}` : null,
+    `provenanceFile: ${stmt.provenance.relativePath}`,
+    `provenanceHash: ${stmt.provenance.sourceFileHash}`,
+    "---"
+  ].filter(Boolean).join("\n");
+  const body = `${frontmatter}
+
+${stmt.content}
+`;
+  try {
+    fs3.writeFileSync(filePath, body);
+    return filePath;
+  } catch {
+    return null;
+  }
+}
+function generateId() {
+  return crypto.randomUUID();
+}
+function hashContent(content) {
+  return crypto.createHash("sha256").update(content).digest("hex").slice(0, 16);
+}
+function tierFromConfidence(confidence) {
+  if (confidence >= 0.95) return "explicit";
+  if (confidence >= 0.8) return "high";
+  if (confidence >= 0.5) return "medium";
+  return "low";
+}
+function readFileSafe(filePath) {
+  try {
+    return fs3.readFileSync(filePath, "utf8");
+  } catch {
+    return null;
+  }
+}
+function isBinary(content) {
+  for (let i = 0; i < Math.min(content.length, 8e3); i++) {
+    if (content.charCodeAt(i) === 0) return true;
+  }
+  return false;
+}
+function parseFrontmatter2(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return null;
+  const fm = {};
+  for (const line of match[1].split("\n")) {
+    const colonIdx = line.indexOf(":");
+    if (colonIdx === -1) continue;
+    const key = line.slice(0, colonIdx).trim();
+    const value = line.slice(colonIdx + 1).trim();
+    fm[key] = value;
+  }
+  return fm;
+}
+function extractBody2(content) {
+  const match = content.match(/^---\n[\s\S]*?\n---\n([\s\S]*)/);
+  return match ? match[1].trim() : content.trim();
+}
+function walkFiles(dir, callback) {
+  for (const entry of fs3.readdirSync(dir, { withFileTypes: true })) {
+    const fullPath = path4.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      walkFiles(fullPath, callback);
+    } else if (entry.name.endsWith(".md")) {
+      callback(fullPath);
+    }
+  }
+}
+
+// src/dedup/index.ts
+import fs4 from "fs";
+import path5 from "path";
+import crypto2 from "crypto";
+function findDuplicates(options) {
+  const startTime = Date.now();
+  const { memoryDir, threshold = 0.85, maxLoad = 1e4 } = options;
+  const memories = loadMemories(memoryDir, options.categories, maxLoad);
+  const duplicates = [];
+  for (let i = 0; i < memories.length; i++) {
+    for (let j = i + 1; j < memories.length; j++) {
+      const sim = computeSimilarity(memories[i].content, memories[j].content);
+      if (sim >= threshold) {
+        duplicates.push({
+          left: memories[i],
+          right: memories[j],
+          similarity: sim,
+          action: sim >= 0.98 ? "merge" : sim >= 0.9 ? "keep_right" : "keep_left"
+        });
+      }
+    }
+  }
+  return {
+    scanned: memories.length,
+    duplicates,
+    durationMs: Date.now() - startTime
+  };
+}
+function findContradictions(options) {
+  const startTime = Date.now();
+  const { memoryDir, maxLoad = 1e4 } = options;
+  const memories = loadMemories(memoryDir, options.categories, maxLoad);
+  const contradictions = [];
+  for (let i = 0; i < memories.length; i++) {
+    for (let j = i + 1; j < memories.length; j++) {
+      const contra = detectContradiction(memories[i], memories[j]);
+      if (contra) {
+        contradictions.push(contra);
+      }
+    }
+  }
+  return {
+    scanned: memories.length,
+    contradictions,
+    durationMs: Date.now() - startTime
+  };
+}
+function computeSimilarity(a, b) {
+  const normA = normalize(a);
+  const normB = normalize(b);
+  if (normA === normB) return 1;
+  if (hashContent2(normA) === hashContent2(normB)) return 0.99;
+  if (normA.length > 50 && normB.length > 50) {
+    if (normA.includes(normB.slice(0, 40)) || normB.includes(normA.slice(0, 40))) {
+      return 0.9;
+    }
+  }
+  const wordsA = new Set(normA.split(/\s+/));
+  const wordsB = new Set(normB.split(/\s+/));
+  const intersection = new Set([...wordsA].filter((w) => wordsB.has(w)));
+  const union = /* @__PURE__ */ new Set([...wordsA, ...wordsB]);
+  if (union.size === 0) return 0;
+  return intersection.size / union.size;
+}
+function normalize(text) {
+  return text.toLowerCase().replace(/[^\w\s']/g, "").replace(/\s+/g, " ").trim();
+}
+var NEGATION_WORDS = /* @__PURE__ */ new Set([
+  "not",
+  "don't",
+  "doesn't",
+  "isn't",
+  "aren't",
+  "won't",
+  "can't",
+  "never",
+  "no",
+  "none",
+  "neither",
+  "nor",
+  "nothing",
+  "nowhere"
+]);
+function detectContradiction(a, b) {
+  const normA = normalize(a.content);
+  const normB = normalize(b.content);
+  const aHasNegation = containsNegation(normA);
+  const bHasNegation = containsNegation(normB);
+  if (aHasNegation === bHasNegation) return null;
+  const strippedA = stripNegation(normA);
+  const strippedB = stripNegation(normB);
+  const sim = computeSimilarity(strippedA, strippedB);
+  if (sim < 0.7) return null;
+  const oppQuantifiers = [
+    ["always", "never"],
+    ["all", "none"],
+    ["every", "no"],
+    ["must", "must not"],
+    ["should", "should not"],
+    ["can", "cannot"]
+  ];
+  for (const [pos, neg] of oppQuantifiers) {
+    if (a.content.toLowerCase().includes(pos) && b.content.toLowerCase().includes(neg) || a.content.toLowerCase().includes(neg) && b.content.toLowerCase().includes(pos)) {
+      return {
+        left: a,
+        right: b,
+        severity: "high",
+        reason: `Opposite quantifiers: "${pos}" vs "${neg}"`
+      };
+    }
+  }
+  return {
+    left: a,
+    right: b,
+    severity: sim >= 0.85 ? "high" : "medium",
+    reason: "Negated version of similar content"
+  };
+}
+function containsNegation(text) {
+  const words = text.split(/\s+/);
+  return words.some((w) => NEGATION_WORDS.has(w));
+}
+function stripNegation(text) {
+  return text.replace(/\b(not|don't|doesn't|isn't|aren't|won't|can't|never|no|none|neither|nor|nothing|nowhere)\b/gi, "").replace(/\s+/g, " ").trim();
+}
+function loadMemories(memoryDir, categories, maxLoad = 1e4) {
+  const result = [];
+  const allCategories = categories ?? ALL_CATEGORY_DIRS;
+  for (const category of allCategories) {
+    if (result.length >= maxLoad) break;
+    const dir = path5.join(memoryDir, category);
+    if (!fs4.existsSync(dir)) continue;
+    walkMdFiles(dir, (filePath) => {
+      if (result.length >= maxLoad) return;
+      const content = readFileSafe2(filePath);
+      if (!content) return;
+      const fm = parseFrontmatter3(content);
+      const body = extractBody3(content);
+      if (!fm?.id || !body) return;
+      result.push({
+        id: fm.id,
+        content: body,
+        category: fm.category ?? category.slice(0, -1),
+        filePath
+      });
+    });
+  }
+  return result;
+}
+function hashContent2(content) {
+  return crypto2.createHash("sha256").update(content).digest("hex").slice(0, 16);
+}
+function readFileSafe2(filePath) {
+  try {
+    return fs4.readFileSync(filePath, "utf8");
+  } catch {
+    return null;
+  }
+}
+function parseFrontmatter3(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return null;
+  const fm = {};
+  for (const line of match[1].split("\n")) {
+    const colonIdx = line.indexOf(":");
+    if (colonIdx === -1) continue;
+    const key = line.slice(0, colonIdx).trim();
+    const value = line.slice(colonIdx + 1).trim();
+    fm[key] = value;
+  }
+  return fm;
+}
+function extractBody3(content) {
+  const match = content.match(/^---\n[\s\S]*?\n---\n([\s\S]*)/);
+  return match ? match[1].trim() : content.trim();
+}
+function walkMdFiles(dir, callback) {
+  for (const entry of fs4.readdirSync(dir, { withFileTypes: true })) {
+    const fullPath = path5.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      walkMdFiles(fullPath, callback);
+    } else if (entry.name.endsWith(".md")) {
+      callback(fullPath);
+    }
+  }
+}
+
+// src/review/index.ts
+import fs5 from "fs";
+import path6 from "path";
+function listReviewItems(options) {
+  const startTime = Date.now();
+  const {
+    memoryDir,
+    reason: filterReason,
+    limit = 50,
+    confidenceThreshold = 0.7
+  } = options;
+  const items = [];
+  const suggestionsDir = path6.join(memoryDir, "suggestions");
+  if (fs5.existsSync(suggestionsDir)) {
+    walkMd(suggestionsDir, (filePath, content) => {
+      if (items.length >= limit) return;
+      const fm = parseFrontmatter4(content);
+      const body = extractBody4(content);
+      if (!fm?.id) return;
+      items.push({
+        id: fm.id,
+        content: body,
+        category: fm.category ?? "suggestion",
+        confidence: parseConfidence(fm.confidence, 0.5),
+        confidenceTier: fm.confidenceTier ?? "low",
+        source: fm.source ?? "unknown",
+        filePath,
+        created: fm.created ?? (/* @__PURE__ */ new Date()).toISOString(),
+        reviewReason: "suggestion"
+      });
+    });
+  }
+  const reviewDir = path6.join(memoryDir, "review");
+  if (fs5.existsSync(reviewDir)) {
+    walkMd(reviewDir, (filePath, content) => {
+      if (items.length >= limit) return;
+      const fm = parseFrontmatter4(content);
+      const body = extractBody4(content);
+      if (!fm?.id) return;
+      items.push({
+        id: fm.id,
+        content: body,
+        category: fm.category ?? "review",
+        confidence: parseConfidence(fm.confidence, 0.5),
+        confidenceTier: fm.confidenceTier ?? "low",
+        source: fm.source ?? "unknown",
+        filePath,
+        created: fm.created ?? (/* @__PURE__ */ new Date()).toISOString(),
+        reviewReason: fm.reviewReason ?? "low_confidence",
+        context: fm.context
+      });
+    });
+  }
+  const categories = ALL_CATEGORY_DIRS;
+  for (const category of categories) {
+    if (items.length >= limit) break;
+    const dir = path6.join(memoryDir, category);
+    if (!fs5.existsSync(dir)) continue;
+    walkMd(dir, (filePath, content) => {
+      if (items.length >= limit) return;
+      const fm = parseFrontmatter4(content);
+      const body = extractBody4(content);
+      if (!fm?.id) return;
+      const confidence = parseConfidence(fm.confidence, 1);
+      if (confidence >= confidenceThreshold) return;
+      if (items.some((i) => i.id === fm.id)) return;
+      items.push({
+        id: fm.id,
+        content: body,
+        category: fm.category ?? category.slice(0, -1),
+        confidence,
+        confidenceTier: fm.confidenceTier ?? "low",
+        source: fm.source ?? "unknown",
+        filePath,
+        created: fm.created ?? (/* @__PURE__ */ new Date()).toISOString(),
+        reviewReason: "low_confidence"
+      });
+    });
+  }
+  const filtered = filterReason ? items.filter((i) => i.reviewReason === filterReason) : items;
+  return {
+    items: filtered.slice(0, limit),
+    total: filtered.length,
+    durationMs: Date.now() - startTime
+  };
+}
+function performReview(memoryDir, itemId, action) {
+  switch (action) {
+    case "approve":
+      return approveItem(memoryDir, itemId);
+    case "dismiss":
+      return dismissItem(memoryDir, itemId);
+    case "flag":
+      return flagItem(memoryDir, itemId);
+  }
+}
+function approveItem(memoryDir, itemId) {
+  const locations = ["suggestions", "review"];
+  for (const loc of locations) {
+    const dir = path6.join(memoryDir, loc);
+    if (!fs5.existsSync(dir)) continue;
+    const found = findFileById(dir, itemId);
+    if (!found) continue;
+    const content = fs5.readFileSync(found, "utf8");
+    const fm = parseFrontmatter4(content);
+    const body = extractBody4(content);
+    if (!fm) return { itemId, action: "approve", message: "Could not parse frontmatter" };
+    const category = fm.category ?? "fact";
+    const targetDir = getCategoryDir(memoryDir, category);
+    const dateDir = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    const outputPath = path6.join(targetDir, dateDir, path6.basename(found));
+    const updatedContent = content.replace(/confidence: [\d.]+/, "confidence: 0.9").replace(/confidenceTier: \w+/, "confidenceTier: high");
+    fs5.mkdirSync(path6.dirname(outputPath), { recursive: true });
+    fs5.writeFileSync(outputPath, updatedContent);
+    fs5.unlinkSync(found);
+    return {
+      itemId,
+      action: "approve",
+      updatedPath: outputPath,
+      message: `Promoted to ${category} with confidence 0.9`
+    };
+  }
+  return { itemId, action: "approve", message: "Item not found" };
+}
+function dismissItem(memoryDir, itemId) {
+  const locations = ["suggestions", "review"];
+  for (const loc of locations) {
+    const dir = path6.join(memoryDir, loc);
+    if (!fs5.existsSync(dir)) continue;
+    const found = findFileById(dir, itemId);
+    if (found) {
+      fs5.unlinkSync(found);
+      return { itemId, action: "dismiss", message: "Dismissed and removed" };
+    }
+  }
+  return { itemId, action: "dismiss", message: "Item not found" };
+}
+function flagItem(memoryDir, itemId) {
+  const locations = ["suggestions", "review"];
+  for (const loc of locations) {
+    const dir = path6.join(memoryDir, loc);
+    if (!fs5.existsSync(dir)) continue;
+    const found = findFileById(dir, itemId);
+    if (found) {
+      const content = fs5.readFileSync(found, "utf8");
+      const fixed = content.replace(
+        /^(---\n)/,
+        `---
+flagged: true
+flaggedAt: ${(/* @__PURE__ */ new Date()).toISOString()}
+`
+      );
+      fs5.writeFileSync(found, fixed);
+      return { itemId, action: "flag", message: "Flagged for further review" };
+    }
+  }
+  return { itemId, action: "flag", message: "Item not found" };
+}
+function findFileById(dir, id) {
+  const files = walkMdPaths(dir);
+  for (const filePath of files) {
+    const content = readFileSafe3(filePath);
+    if (!content) continue;
+    const fm = parseFrontmatter4(content);
+    if (fm?.id === id) return filePath;
+  }
+  return null;
+}
+function parseConfidence(value, fallback) {
+  if (typeof value === "number") return Number.isFinite(value) ? value : fallback;
+  if (typeof value === "string") {
+    const n = parseFloat(value);
+    return Number.isFinite(n) ? n : fallback;
+  }
+  return fallback;
+}
+function readFileSafe3(filePath) {
+  try {
+    return fs5.readFileSync(filePath, "utf8");
+  } catch {
+    return null;
+  }
+}
+function parseFrontmatter4(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return null;
+  const fm = {};
+  for (const line of match[1].split("\n")) {
+    const colonIdx = line.indexOf(":");
+    if (colonIdx === -1) continue;
+    const key = line.slice(0, colonIdx).trim();
+    const value = line.slice(colonIdx + 1).trim();
+    fm[key] = value;
+  }
+  return fm;
+}
+function extractBody4(content) {
+  const match = content.match(/^---\n[\s\S]*?\n---\n([\s\S]*)/);
+  return match ? match[1].trim() : content.trim();
+}
+function walkMd(dir, callback) {
+  for (const entry of fs5.readdirSync(dir, { withFileTypes: true })) {
+    const fullPath = path6.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      walkMd(fullPath, callback);
+    } else if (entry.name.endsWith(".md")) {
+      const content = readFileSafe3(fullPath);
+      if (content) callback(fullPath, content);
+    }
+  }
+}
+function walkMdPaths(dir) {
+  const results = [];
+  for (const entry of fs5.readdirSync(dir, { withFileTypes: true })) {
+    const fullPath = path6.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...walkMdPaths(fullPath));
+    } else if (entry.name.endsWith(".md")) {
+      results.push(fullPath);
+    }
+  }
+  return results;
+}
+
+// src/sync/index.ts
+import fs6 from "fs";
+import path7 from "path";
+import crypto3 from "crypto";
+var DEFAULT_EXTENSIONS = /* @__PURE__ */ new Set([".md", ".txt", ".mdx", ".rst"]);
+var DEFAULT_EXCLUDE2 = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  ".engram",
+  "coverage"
+]);
+function syncChanges(options) {
+  const startTime = Date.now();
+  const {
+    sourceDir,
+    memoryDir,
+    extensions = [...DEFAULT_EXTENSIONS],
+    excludeDirs = [],
+    dryRun = false
+  } = options;
+  const extSet = new Set(extensions);
+  const excludeSet = /* @__PURE__ */ new Set([...DEFAULT_EXCLUDE2, ...excludeDirs]);
+  const stateFilePath = options.stateFile ?? path7.join(memoryDir, ".sync-state.json");
+  const prevState = loadState(stateFilePath);
+  const currentFiles = scanFiles(sourceDir, extSet, excludeSet);
+  const changes = computeDiff(currentFiles, prevState.fileHashes, sourceDir);
+  const added = changes.filter((c) => c.type === "added").map((c) => c.relativePath);
+  const modified = changes.filter((c) => c.type === "modified");
+  const deleted = changes.filter((c) => c.type === "deleted").map((c) => c.relativePath);
+  if (!dryRun) {
+    const newState = {
+      fileHashes: {},
+      lastSyncAt: (/* @__PURE__ */ new Date()).toISOString(),
+      version: 1
+    };
+    for (const [relPath, hash] of Object.entries(currentFiles)) {
+      newState.fileHashes[relPath] = hash;
+    }
+    fs6.mkdirSync(path7.dirname(stateFilePath), { recursive: true });
+    fs6.writeFileSync(stateFilePath, JSON.stringify(newState, null, 2));
+  }
+  return {
+    scanned: Object.keys(currentFiles).length,
+    changed: changes,
+    unchanged: Object.keys(currentFiles).length - changes.filter((c) => c.type !== "deleted").length,
+    deleted,
+    added,
+    durationMs: Date.now() - startTime,
+    stateFile: stateFilePath
+  };
+}
+function watchForChanges(options, onChange) {
+  const { sourceDir, extensions, excludeDirs } = options;
+  const extSet = new Set(extensions ?? DEFAULT_EXTENSIONS);
+  const excludeSet = /* @__PURE__ */ new Set([...DEFAULT_EXCLUDE2, ...excludeDirs ?? []]);
+  let lastHashes = {};
+  const currentFiles = scanFiles(sourceDir, extSet, excludeSet);
+  lastHashes = { ...currentFiles };
+  const interval = setInterval(() => {
+    const nowFiles = scanFiles(sourceDir, extSet, excludeSet);
+    const changes = computeDiff(nowFiles, lastHashes, sourceDir);
+    if (changes.length > 0) {
+      for (const change of changes) {
+        if (change.type === "deleted") {
+          delete lastHashes[change.relativePath];
+        } else {
+          lastHashes[change.relativePath] = change.currentHash;
+        }
+      }
+      onChange(changes);
+    }
+  }, 5e3);
+  return {
+    stop: () => clearInterval(interval)
+  };
+}
+function scanFiles(root, extensions, exclude) {
+  const result = {};
+  function walk(dir) {
+    let entries;
+    try {
+      entries = fs6.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (exclude.has(entry.name)) continue;
+      const fullPath = path7.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        walk(fullPath);
+      } else if (entry.isFile()) {
+        const ext = path7.extname(entry.name).toLowerCase();
+        if (!extensions.has(ext)) continue;
+        const relPath = path7.relative(root, fullPath);
+        try {
+          const content = fs6.readFileSync(fullPath, "utf8");
+          result[relPath] = hashContent3(content);
+        } catch {
+        }
+      }
+    }
+  }
+  walk(root);
+  return result;
+}
+function computeDiff(current, previous, sourceDir) {
+  const changes = [];
+  for (const [relPath, hash] of Object.entries(current)) {
+    const fullPath = path7.join(sourceDir, relPath);
+    if (!(relPath in previous)) {
+      let size = 0;
+      try {
+        size = fs6.statSync(fullPath).size;
+      } catch {
+      }
+      changes.push({
+        filePath: fullPath,
+        relativePath: relPath,
+        type: "added",
+        currentHash: hash,
+        size
+      });
+    } else if (previous[relPath] !== hash) {
+      let size = 0;
+      try {
+        size = fs6.statSync(fullPath).size;
+      } catch {
+      }
+      changes.push({
+        filePath: fullPath,
+        relativePath: relPath,
+        type: "modified",
+        currentHash: hash,
+        previousHash: previous[relPath],
+        size
+      });
+    }
+  }
+  for (const relPath of Object.keys(previous)) {
+    if (!(relPath in current)) {
+      changes.push({
+        filePath: path7.join(sourceDir, relPath),
+        relativePath: relPath,
+        type: "deleted",
+        currentHash: "",
+        size: 0
+      });
+    }
+  }
+  return changes;
+}
+function loadState(stateFilePath) {
+  try {
+    const raw = fs6.readFileSync(stateFilePath, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return {
+      fileHashes: {},
+      lastSyncAt: (/* @__PURE__ */ new Date(0)).toISOString(),
+      version: 1
+    };
+  }
+}
+function hashContent3(content) {
+  return crypto3.createHash("sha256").update(content).digest("hex").slice(0, 16);
+}
+
+// src/connectors/index.ts
+import fs7 from "fs";
+import path8 from "path";
+var BUILTIN_CONNECTORS = [
+  {
+    id: "claude-code",
+    name: "Claude Code",
+    version: "1.0.0",
+    description: "Anthropic's Claude Code CLI \u2014 direct memory access via MCP",
+    capabilities: {
+      observe: true,
+      recall: true,
+      store: true,
+      search: true,
+      entities: true,
+      realtimeSync: true,
+      batch: false,
+      maxBudgetChars: 32e3,
+      connectionType: "mcp"
+    },
+    configSchema: {
+      mcpServerUrl: "URL of the MCP Remnic server",
+      namespace: "Optional namespace (default: 'default')"
+    },
+    homepage: "https://claude.ai/code",
+    author: "Anthropic",
+    tags: ["official", "ai", "claude"]
+  },
+  {
+    id: "codex-cli",
+    name: "Codex CLI",
+    version: "1.0.0",
+    description: "OpenAI Codex CLI \u2014 memory via MCP tool",
+    capabilities: {
+      observe: true,
+      recall: true,
+      store: true,
+      search: false,
+      entities: false,
+      realtimeSync: false,
+      batch: true,
+      maxBudgetChars: 8e3,
+      connectionType: "mcp"
+    },
+    configSchema: {
+      mcpServerUrl: "URL of the MCP Remnic server",
+      namespace: "Optional namespace"
+    },
+    homepage: "https://openai.com/codex",
+    author: "OpenAI",
+    tags: ["official", "ai", "codex"]
+  },
+  {
+    id: "cursor",
+    name: "Cursor IDE",
+    version: "1.0.0",
+    description: "Cursor IDE \u2014 memory via config file + tool calls",
+    capabilities: {
+      observe: false,
+      recall: true,
+      store: false,
+      search: true,
+      entities: false,
+      realtimeSync: false,
+      batch: false,
+      maxBudgetChars: 32e3,
+      connectionType: "embedded"
+    },
+    configSchema: {
+      memoryDir: "Path to Remnic memory directory"
+    },
+    homepage: "https://cursor.com",
+    author: "Cursor Inc.",
+    tags: ["official", "ide"]
+  },
+  {
+    id: "cline",
+    name: "Cline",
+    version: "1.0.0",
+    description: "VS Code Cline extension \u2014 memory via MCP",
+    capabilities: {
+      observe: true,
+      recall: true,
+      store: true,
+      search: false,
+      entities: false,
+      realtimeSync: false,
+      batch: true,
+      maxBudgetChars: 8e3,
+      connectionType: "mcp"
+    },
+    configSchema: {
+      mcpServerUrl: "URL of the MCP Remnic server",
+      namespace: "Optional namespace"
+    },
+    homepage: "https://github.com/cline/cline",
+    author: "Cline",
+    tags: ["community", "vscode"]
+  },
+  {
+    id: "github-copilot",
+    name: "GitHub Copilot",
+    version: "1.0.0",
+    description: "GitHub Copilot \u2014 memory via MCP server",
+    capabilities: {
+      observe: false,
+      recall: true,
+      store: false,
+      search: true,
+      entities: false,
+      realtimeSync: false,
+      batch: false,
+      maxBudgetChars: 16e3,
+      connectionType: "mcp"
+    },
+    configSchema: {
+      mcpServerUrl: "URL of the MCP Remnic server"
+    },
+    homepage: "https://github.com/features/copilot",
+    author: "GitHub",
+    tags: ["official", "ai", "github"]
+  },
+  {
+    id: "roo-code",
+    name: "Roo Code",
+    version: "1.0.0",
+    description: "Roo Code \u2014 memory via MCP",
+    capabilities: {
+      observe: true,
+      recall: true,
+      store: true,
+      search: false,
+      entities: false,
+      realtimeSync: false,
+      batch: true,
+      maxBudgetChars: 16e3,
+      connectionType: "mcp"
+    },
+    configSchema: {
+      mcpServerUrl: "URL of the MCP Remnic server",
+      namespace: "Optional namespace"
+    },
+    homepage: "https://roocode.com",
+    author: "Roo Code",
+    tags: ["community", "vscode"]
+  },
+  {
+    id: "windsurf",
+    name: "Windsurf",
+    version: "1.0.0",
+    description: "Windsurf IDE \u2014 memory via MCP",
+    capabilities: {
+      observe: true,
+      recall: true,
+      store: true,
+      search: true,
+      entities: false,
+      realtimeSync: false,
+      batch: false,
+      maxBudgetChars: 32e3,
+      connectionType: "mcp"
+    },
+    configSchema: {
+      mcpServerUrl: "URL of the MCP Remnic server"
+    },
+    homepage: "https://windsurf.com",
+    author: "Codeium",
+    tags: ["official", "ide"]
+  },
+  {
+    id: "amp",
+    name: "Amp",
+    version: "1.0.0",
+    description: "Amp coding agent \u2014 memory via MCP",
+    capabilities: {
+      observe: true,
+      recall: true,
+      store: true,
+      search: true,
+      entities: false,
+      realtimeSync: false,
+      batch: false,
+      maxBudgetChars: 32e3,
+      connectionType: "mcp"
+    },
+    configSchema: {
+      mcpServerUrl: "URL of the MCP Remnic server"
+    },
+    homepage: "https://ampcode.com",
+    author: "Sourcegraph",
+    tags: ["official", "ai"]
+  },
+  {
+    id: "replit",
+    name: "Replit Agent",
+    version: "1.0.0",
+    description: "Replit Agent \u2014 memory via HTTP API (reduced capabilities)",
+    capabilities: {
+      observe: true,
+      recall: true,
+      store: true,
+      search: false,
+      entities: false,
+      realtimeSync: false,
+      batch: false,
+      maxBudgetChars: 8e3,
+      connectionType: "http"
+    },
+    configSchema: {
+      apiUrl: "URL of the Remnic HTTP API",
+      authToken: "Bearer token for authentication"
+    },
+    homepage: "https://replit.com",
+    author: "Replit",
+    tags: ["official", "cloud"]
+  },
+  {
+    id: "generic-mcp",
+    name: "Generic MCP Client",
+    version: "1.0.0",
+    description: "Any MCP-compatible client \u2014 connect via standard MCP protocol",
+    capabilities: {
+      observe: true,
+      recall: true,
+      store: true,
+      search: true,
+      entities: true,
+      realtimeSync: true,
+      batch: true,
+      maxBudgetChars: 64e3,
+      connectionType: "mcp"
+    },
+    configSchema: {
+      mcpServerUrl: "URL of the MCP Remnic server",
+      namespace: "Optional namespace",
+      authToken: "Bearer token for authentication"
+    },
+    homepage: "https://github.com/joshuaswarren/remnic",
+    author: "Remnic",
+    tags: ["generic", "mcp"]
+  }
+];
+var REGISTRY_DIR_NAME = ".engram-connectors";
+function getRegistryPath() {
+  const configDir = process.env.XDG_CONFIG_HOME ? path8.join(process.env.XDG_CONFIG_HOME, "engram") : path8.join(process.env.HOME ?? "~", ".config", "engram");
+  return path8.join(configDir, REGISTRY_DIR_NAME, "registry.json");
+}
+function loadRegistry() {
+  const regPath = getRegistryPath();
+  if (!fs7.existsSync(regPath)) {
+    const registry = {
+      connectors: BUILTIN_CONNECTORS,
+      registryPath: regPath
+    };
+    saveRegistry(registry);
+    return registry;
+  }
+  const raw = fs7.readFileSync(regPath, "utf8");
+  try {
+    const parsed = JSON.parse(raw);
+    const customIds = new Set((parsed.connectors ?? []).map((c) => c.id));
+    const merged = [
+      ...BUILTIN_CONNECTORS.filter((b) => !customIds.has(b.id)),
+      ...parsed.connectors ?? []
+    ];
+    return {
+      connectors: merged,
+      registryPath: regPath
+    };
+  } catch {
+    const registry = {
+      connectors: BUILTIN_CONNECTORS,
+      registryPath: regPath
+    };
+    saveRegistry(registry);
+    return registry;
+  }
+}
+function saveRegistry(registry) {
+  const regPath = registry.registryPath;
+  fs7.mkdirSync(path8.dirname(regPath), { recursive: true });
+  fs7.writeFileSync(regPath, JSON.stringify({ connectors: registry.connectors }, null, 2));
+}
+function listConnectors() {
+  const registry = loadRegistry();
+  const connectorsDir = getConnectorsDir();
+  const installedIds = /* @__PURE__ */ new Set();
+  if (fs7.existsSync(connectorsDir)) {
+    for (const entry of fs7.readdirSync(connectorsDir)) {
+      if (entry.endsWith(".json")) {
+        try {
+          const config = JSON.parse(
+            fs7.readFileSync(path8.join(connectorsDir, entry), "utf8")
+          );
+          installedIds.add(config.connectorId);
+        } catch {
+        }
+      }
+    }
+  }
+  const available = registry.connectors.map((manifest) => ({
+    ...manifest,
+    installed: installedIds.has(manifest.id)
+  }));
+  const installed = [];
+  for (const id of installedIds) {
+    const configPath = path8.join(connectorsDir, `${id}.json`);
+    try {
+      const config = JSON.parse(fs7.readFileSync(configPath, "utf8"));
+      installed.push({
+        connectorId: id,
+        config,
+        status: "installed",
+        installedAt: config.installedAt
+      });
+    } catch {
+    }
+  }
+  return { installed, available };
+}
+function installConnector(options) {
+  const registry = loadRegistry();
+  const manifest = registry.connectors.find((c) => c.id === options.connectorId);
+  if (!manifest) {
+    return {
+      connectorId: options.connectorId,
+      status: "error",
+      message: `Unknown connector: ${options.connectorId}`
+    };
+  }
+  const existing = listConnectors().installed.find(
+    (c) => c.connectorId === options.connectorId
+  );
+  if (existing && !options.force) {
+    return {
+      connectorId: options.connectorId,
+      status: "already_installed",
+      message: "Already installed. Use --force to reinstall."
+    };
+  }
+  const configDir = getConnectorsDir();
+  fs7.mkdirSync(configDir, { recursive: true });
+  const configPath = path8.join(configDir, `${options.connectorId}.json`);
+  const resolvedConfig = {
+    connectorId: options.connectorId,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    ...options.config
+  };
+  fs7.writeFileSync(configPath, JSON.stringify(resolvedConfig, null, 2));
+  return {
+    connectorId: options.connectorId,
+    status: "installed",
+    configPath,
+    message: `Installed ${manifest.name} v${manifest.version}`
+  };
+}
+function removeConnector(connectorId) {
+  const configDir = getConnectorsDir();
+  const configPath = path8.join(configDir, `${connectorId}.json`);
+  if (!fs7.existsSync(configPath)) {
+    return {
+      connectorId,
+      configPath,
+      message: "Not installed"
+    };
+  }
+  fs7.unlinkSync(configPath);
+  return {
+    connectorId,
+    configPath,
+    message: "Removed"
+  };
+}
+async function doctorConnector(connectorId) {
+  const installed = listConnectors().installed;
+  const instance = installed.find((c) => c.connectorId === connectorId);
+  if (!instance) {
+    return {
+      connectorId,
+      checks: [{ name: "Installed", ok: false, detail: "Not installed" }],
+      healthy: false
+    };
+  }
+  const configPath = path8.join(getConnectorsDir(), `${connectorId}.json`);
+  const checks = [];
+  checks.push({
+    name: "Config file",
+    ok: fs7.existsSync(configPath),
+    detail: configPath
+  });
+  try {
+    const raw = fs7.readFileSync(configPath, "utf8");
+    JSON.parse(raw);
+    checks.push({ name: "Config valid", ok: true, detail: "OK" });
+  } catch (e) {
+    checks.push({ name: "Config valid", ok: false, detail: String(e) });
+  }
+  const mcpUrl = instance.config.mcpServerUrl;
+  if (mcpUrl) {
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), 3e3);
+      const response = await fetch(mcpUrl, { signal: controller.signal });
+      clearTimeout(timeoutId);
+      checks.push({ name: "MCP server", ok: response.ok, detail: mcpUrl });
+    } catch (e) {
+      checks.push({
+        name: "MCP server",
+        ok: false,
+        detail: `Cannot reach ${mcpUrl}: ${e instanceof Error ? e.message : "unknown"}`
+      });
+    }
+  }
+  const memoryDir = instance.config.memoryDir;
+  if (memoryDir) {
+    if (fs7.existsSync(memoryDir)) {
+      checks.push({ name: "Memory directory", ok: true, detail: memoryDir });
+    } else {
+      checks.push({ name: "Memory directory", ok: false, detail: `Not found: ${memoryDir}` });
+    }
+  }
+  const healthy = checks.every((c) => c.ok);
+  return { connectorId, checks, healthy };
+}
+function getConnectorsDir() {
+  const configDir = process.env.XDG_CONFIG_HOME ? path8.join(process.env.XDG_CONFIG_HOME, "engram") : path8.join(process.env.HOME ?? "~", ".config", "engram");
+  return path8.join(configDir, REGISTRY_DIR_NAME, "connectors");
+}
+
+// src/spaces/index.ts
+import fs8 from "fs";
+import path9 from "path";
+import crypto4 from "crypto";
+var MANIFEST_VERSION = 1;
+function getSpacesDir(baseDir) {
+  const homeDir = baseDir ?? process.env.HOME ?? "~";
+  return path9.join(homeDir, ".config", "engram", "spaces");
+}
+function getManifestPath(baseDir) {
+  return path9.join(getSpacesDir(baseDir), "manifest.json");
+}
+function loadManifest(baseDir, memoryDirOverride) {
+  const manifestPath = getManifestPath(baseDir);
+  if (!fs8.existsSync(manifestPath)) {
+    const personalSpace = createPersonalSpace(baseDir, memoryDirOverride);
+    const manifest = {
+      activeSpaceId: personalSpace.id,
+      spaces: [personalSpace],
+      version: MANIFEST_VERSION
+    };
+    saveManifest(manifest, baseDir);
+    return manifest;
+  }
+  const raw = JSON.parse(fs8.readFileSync(manifestPath, "utf8"));
+  return raw;
+}
+function saveManifest(manifest, baseDir) {
+  const manifestPath = getManifestPath(baseDir);
+  fs8.mkdirSync(path9.dirname(manifestPath), { recursive: true });
+  fs8.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2) + "\n");
+}
+function createPersonalSpace(baseDir, memoryDirOverride) {
+  const homeDir = baseDir ?? process.env.HOME ?? "~";
+  const standalonePath = path9.join(homeDir, ".engram", "memory");
+  const openclawPath = path9.join(homeDir, ".openclaw", "workspace", "memory", "local");
+  const memoryDir = memoryDirOverride ?? process.env.ENGRAM_MEMORY_DIR ?? (fs8.existsSync(standalonePath) ? standalonePath : fs8.existsSync(openclawPath) ? openclawPath : standalonePath);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    id: "personal",
+    name: "Personal",
+    kind: "personal",
+    description: "Default personal memory space",
+    memoryDir,
+    createdAt: now,
+    updatedAt: now,
+    owner: process.env.USER
+  };
+}
+function listSpaces(baseDir) {
+  const manifest = loadManifest(baseDir);
+  return manifest.spaces;
+}
+function getActiveSpace(baseDir) {
+  const manifest = loadManifest(baseDir);
+  const space = manifest.spaces.find((s) => s.id === manifest.activeSpaceId);
+  if (!space) throw new Error(`Active space ${manifest.activeSpaceId} not found`);
+  return space;
+}
+function createSpace(options) {
+  const manifest = loadManifest(options.baseDir);
+  const id = options.name.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-");
+  if (manifest.spaces.some((s) => s.id === id)) {
+    throw new Error(`Space "${id}" already exists`);
+  }
+  if (options.parentSpaceId && !manifest.spaces.some((s) => s.id === options.parentSpaceId)) {
+    throw new Error(`Parent space "${options.parentSpaceId}" not found`);
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const memoryDir = options.memoryDir ?? path9.join(
+    getSpacesDir(options.baseDir),
+    id,
+    "memory"
+  );
+  const space = {
+    id,
+    name: options.name,
+    kind: options.kind,
+    description: options.description,
+    memoryDir,
+    createdAt: now,
+    updatedAt: now,
+    owner: process.env.USER,
+    parentSpaceId: options.parentSpaceId
+  };
+  fs8.mkdirSync(memoryDir, { recursive: true });
+  manifest.spaces.push(space);
+  manifest.updatedAt = now;
+  saveManifest(manifest, options.baseDir);
+  appendAudit({
+    action: "space.create",
+    sourceSpaceId: id,
+    details: `Created ${options.kind} space "${options.name}"`
+  }, options.baseDir);
+  return space;
+}
+function deleteSpace(spaceId, baseDir) {
+  const manifest = loadManifest(baseDir);
+  if (spaceId === "personal") {
+    throw new Error("Cannot delete the personal space");
+  }
+  const idx = manifest.spaces.findIndex((s) => s.id === spaceId);
+  if (idx === -1) throw new Error(`Space "${spaceId}" not found`);
+  if (manifest.activeSpaceId === spaceId) {
+    manifest.activeSpaceId = "personal";
+  }
+  for (const space of manifest.spaces) {
+    if (space.parentSpaceId === spaceId) {
+      space.parentSpaceId = void 0;
+    }
+  }
+  manifest.spaces.splice(idx, 1);
+  saveManifest(manifest, baseDir);
+  appendAudit({
+    action: "space.delete",
+    sourceSpaceId: spaceId,
+    details: `Deleted space "${spaceId}"`
+  }, baseDir);
+}
+function switchSpace(spaceId, baseDir) {
+  const manifest = loadManifest(baseDir);
+  const space = manifest.spaces.find((s) => s.id === spaceId);
+  if (!space) throw new Error(`Space "${spaceId}" not found`);
+  const previousId = manifest.activeSpaceId;
+  manifest.activeSpaceId = spaceId;
+  saveManifest(manifest, baseDir);
+  appendAudit({
+    action: "space.switch",
+    sourceSpaceId: previousId,
+    targetSpaceId: spaceId,
+    details: `Switched from "${previousId}" to "${spaceId}"`
+  }, baseDir);
+  return {
+    previousSpaceId: previousId,
+    currentSpaceId: spaceId,
+    message: `Switched to "${space.name}"`
+  };
+}
+function pushToSpace(sourceSpaceId, targetSpaceId, options) {
+  const startTime = Date.now();
+  const manifest = loadManifest(options?.baseDir);
+  const source = manifest.spaces.find((s) => s.id === sourceSpaceId);
+  const target = manifest.spaces.find((s) => s.id === targetSpaceId);
+  if (!source) throw new Error(`Source space "${sourceSpaceId}" not found`);
+  if (!target) throw new Error(`Target space "${targetSpaceId}" not found`);
+  const result = copyMemories(source.memoryDir, target.memoryDir, {
+    filterIds: options?.memoryIds,
+    force: options?.force
+  });
+  appendAudit({
+    action: "space.push",
+    sourceSpaceId,
+    targetSpaceId,
+    details: `Pushed ${result.merged} memories, ${result.conflicts.length} conflicts`
+  }, options?.baseDir);
+  return {
+    sourceSpaceId,
+    targetSpaceId,
+    memoriesPushed: result.merged,
+    conflicts: result.conflicts,
+    durationMs: Date.now() - startTime
+  };
+}
+function pullFromSpace(sourceSpaceId, targetSpaceId, options) {
+  const startTime = Date.now();
+  const manifest = loadManifest(options?.baseDir);
+  const source = manifest.spaces.find((s) => s.id === sourceSpaceId);
+  const target = manifest.spaces.find((s) => s.id === targetSpaceId);
+  if (!source) throw new Error(`Source space "${sourceSpaceId}" not found`);
+  if (!target) throw new Error(`Target space "${targetSpaceId}" not found`);
+  const result = copyMemories(source.memoryDir, target.memoryDir, {
+    filterIds: options?.memoryIds,
+    force: options?.force
+  });
+  appendAudit({
+    action: "space.pull",
+    sourceSpaceId,
+    targetSpaceId,
+    details: `Pulled ${result.merged} memories, ${result.conflicts.length} conflicts`
+  }, options?.baseDir);
+  return {
+    sourceSpaceId,
+    targetSpaceId,
+    memoriesPulled: result.merged,
+    conflicts: result.conflicts,
+    durationMs: Date.now() - startTime
+  };
+}
+function shareSpace(spaceId, members, baseDir) {
+  const manifest = loadManifest(baseDir);
+  const space = manifest.spaces.find((s) => s.id === spaceId);
+  if (!space) throw new Error(`Space "${spaceId}" not found`);
+  if (space.kind === "personal") throw new Error("Cannot share personal space");
+  space.members = [.../* @__PURE__ */ new Set([...space.members ?? [], ...members])];
+  space.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  saveManifest(manifest, baseDir);
+  appendAudit({
+    action: "space.share",
+    sourceSpaceId: spaceId,
+    details: `Shared with: ${members.join(", ")}`
+  }, baseDir);
+  return {
+    spaceId,
+    sharedWith: members,
+    message: `Shared "${space.name}" with ${members.length} member(s)`
+  };
+}
+function promoteSpace(sourceSpaceId, targetSpaceId, options) {
+  const startTime = Date.now();
+  const manifest = loadManifest(options?.baseDir);
+  const source = manifest.spaces.find((s) => s.id === sourceSpaceId);
+  const target = manifest.spaces.find((s) => s.id === targetSpaceId);
+  if (!source) throw new Error(`Source space "${sourceSpaceId}" not found`);
+  if (!target) throw new Error(`Target space "${targetSpaceId}" not found`);
+  if (source.parentSpaceId !== targetSpaceId && target.parentSpaceId !== sourceSpaceId) {
+    if (!options?.force) {
+      throw new Error("Spaces must have a parent-child relationship for promotion. Use --force to override.");
+    }
+  }
+  const result = copyMemories(source.memoryDir, target.memoryDir, {
+    filterIds: options?.memoryIds,
+    force: options?.forceOverwrite !== void 0 ? options.forceOverwrite : options?.force ?? false
+  });
+  appendAudit({
+    action: "space.promote",
+    sourceSpaceId,
+    targetSpaceId,
+    details: `Promoted ${result.merged} memories from "${source.name}" to "${target.name}"`
+  }, options?.baseDir);
+  return {
+    sourceSpaceId,
+    targetSpaceId,
+    memoriesPromoted: result.merged,
+    conflicts: result.conflicts,
+    durationMs: Date.now() - startTime
+  };
+}
+function mergeSpaces(sourceSpaceId, targetSpaceId, options) {
+  const startTime = Date.now();
+  const manifest = loadManifest(options?.baseDir);
+  const source = manifest.spaces.find((s) => s.id === sourceSpaceId);
+  const target = manifest.spaces.find((s) => s.id === targetSpaceId);
+  if (!source) throw new Error(`Source space "${sourceSpaceId}" not found`);
+  if (!target) throw new Error(`Target space "${targetSpaceId}" not found`);
+  const result = copyMemories(source.memoryDir, target.memoryDir, {
+    force: options?.force
+  });
+  appendAudit({
+    action: "space.merge",
+    sourceSpaceId,
+    targetSpaceId,
+    details: `Merged: ${result.merged} merged, ${result.conflicts.length} conflicts, ${result.skipped} skipped`
+  }, options?.baseDir);
+  return {
+    ...result,
+    durationMs: Date.now() - startTime
+  };
+}
+function getAuditLog(baseDir) {
+  const auditPath = path9.join(getSpacesDir(baseDir), "audit.jsonl");
+  if (!fs8.existsSync(auditPath)) return [];
+  const lines = fs8.readFileSync(auditPath, "utf8").trim().split("\n");
+  return lines.filter((l) => l.trim()).map((l) => JSON.parse(l));
+}
+function appendAudit(entry, baseDir) {
+  const auditPath = path9.join(getSpacesDir(baseDir), "audit.jsonl");
+  fs8.mkdirSync(path9.dirname(auditPath), { recursive: true });
+  const full = {
+    id: crypto4.randomUUID(),
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    ...entry
+  };
+  fs8.appendFileSync(auditPath, JSON.stringify(full) + "\n");
+}
+function copyMemories(sourceDir, targetDir, options) {
+  let merged = 0;
+  const conflicts = [];
+  let skipped = 0;
+  if (!fs8.existsSync(sourceDir)) {
+    return { merged: 0, conflicts: [], skipped: 0 };
+  }
+  fs8.mkdirSync(targetDir, { recursive: true });
+  const sourceFiles = walkMd2(sourceDir);
+  for (const sourcePath of sourceFiles) {
+    const content = fs8.readFileSync(sourcePath, "utf8");
+    const relativePath = path9.relative(sourceDir, sourcePath);
+    const targetPath = path9.join(targetDir, relativePath);
+    const sourceHash = hashContent4(content);
+    if (options?.filterIds?.length) {
+      const fm = parseSimpleFrontmatter(content);
+      if (!fm?.id || !options.filterIds.includes(fm.id)) {
+        skipped++;
+        continue;
+      }
+    }
+    if (fs8.existsSync(targetPath) && !options?.force) {
+      const targetContent = fs8.readFileSync(targetPath, "utf8");
+      const targetHash = hashContent4(targetContent);
+      if (sourceHash !== targetHash) {
+        conflicts.push({
+          memoryId: parseSimpleFrontmatter(content)?.id ?? relativePath,
+          sourcePath,
+          targetPath,
+          conflictType: "content_mismatch",
+          sourceHash,
+          targetHash
+        });
+        continue;
+      }
+      skipped++;
+      continue;
+    }
+    fs8.mkdirSync(path9.dirname(targetPath), { recursive: true });
+    fs8.writeFileSync(targetPath, content);
+    merged++;
+  }
+  return { merged, conflicts, skipped };
+}
+function hashContent4(content) {
+  return crypto4.createHash("sha256").update(content).digest("hex").slice(0, 16);
+}
+function walkMd2(dir) {
+  const results = [];
+  function walk(d) {
+    for (const entry of fs8.readdirSync(d, { withFileTypes: true })) {
+      const fullPath = path9.join(d, entry.name);
+      if (entry.isDirectory()) {
+        walk(fullPath);
+      } else if (entry.name.endsWith(".md")) {
+        results.push(fullPath);
+      }
+    }
+  }
+  walk(dir);
+  return results;
+}
+function parseSimpleFrontmatter(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return null;
+  const fm = {};
+  for (const line of match[1].split("\n")) {
+    const colonIdx = line.indexOf(":");
+    if (colonIdx === -1) continue;
+    const key = line.slice(0, colonIdx).trim();
+    const value = line.slice(colonIdx + 1).trim();
+    fm[key] = value;
+  }
+  return fm;
+}
+export {
+  BootstrapEngine,
+  EngramAccessHttpServer,
+  EngramAccessInputError,
+  EngramAccessService,
+  EngramMcpServer,
+  ExtractionEngine,
+  LanceDbBackend,
+  MeilisearchBackend,
+  OramaBackend,
+  Orchestrator,
+  QmdClient,
+  StorageManager,
+  buildEntityRecallSection,
+  createSpace,
+  curate,
+  defaultWorkspaceDir,
+  deleteSpace,
+  doctorConnector,
+  findContradictions,
+  findDuplicates,
+  formatZodError,
+  generateContextTree,
+  generateToken,
+  getActiveSpace,
+  getAllValidTokens,
+  getAllValidTokensCached,
+  getAuditLog,
+  getManifestPath,
+  getSpacesDir,
+  initLogger,
+  installConnector,
+  isTrustZoneName,
+  listConnectors,
+  listReviewItems,
+  listSpaces,
+  listTokens,
+  loadDaySummaryPrompt,
+  loadManifest,
+  loadRegistry,
+  loadTokenStore,
+  log,
+  memoryStoreRequestSchema,
+  mergeSpaces,
+  migrateFromEngram,
+  observeRequestSchema,
+  onboard,
+  parseConfig,
+  performReview,
+  promoteSpace,
+  pullFromSpace,
+  pushToSpace,
+  recallRequestSchema,
+  removeConnector,
+  resolveConnectorFromToken,
+  revokeToken,
+  rollbackFromEngramMigration,
+  sanitizeSessionKeyForFilename,
+  saveManifest,
+  saveRegistry,
+  saveTokenStore,
+  shareSpace,
+  suggestionSubmitRequestSchema,
+  switchSpace,
+  syncChanges,
+  validateRequest,
+  watchForChanges
+};
+//# sourceMappingURL=index.js.map