@orquentra/codebuddy 2.5.0 → 2.6.2

package/dist/chunk-S6VEG4S2.js

@@ -0,0 +1,991 @@
+import {
+  redactPersisted
+} from "./chunk-GDJH7XJC.js";
+import {
+  assertNoSymlinkBetween,
+  composeMarkdown,
+  parseFrontMatter,
+  writeAtomic
+} from "./chunk-5KZY6OTG.js";
+import {
+  __export
+} from "./chunk-PZ5AY32C.js";
+
+// package.json
+var package_default = {
+  name: "@orquentra/codebuddy",
+  version: "2.6.2",
+  description: "Local-first project context and memory for AI coding agents.",
+  type: "module",
+  license: "MIT",
+  publishConfig: {
+    access: "public"
+  },
+  author: "Orquentra Inc",
+  repository: {
+    type: "git",
+    url: "https://github.com/Orquentra-Inc/CodeBuddy"
+  },
+  engines: {
+    node: ">=20"
+  },
+  bin: {
+    codebuddy: "./dist/cli/index.js"
+  },
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.js"
+    },
+    "./langgraph": {
+      types: "./dist/langgraph/index.d.ts",
+      import: "./dist/langgraph/index.js"
+    }
+  },
+  files: [
+    "dist",
+    "src/db/migrations",
+    "README.md",
+    "CLAUDE_CODEX.md",
+    "ARCHITECTURE.md",
+    "WORKFLOW.md",
+    "LICENSE",
+    "docker-compose.yml",
+    "examples"
+  ],
+  scripts: {
+    build: "tsup",
+    dev: "tsx src/cli/index.ts",
+    "db:generate": "drizzle-kit generate",
+    "db:migrate": "drizzle-kit migrate",
+    typecheck: "tsc --noEmit",
+    test: "vitest run --passWithNoTests",
+    "test:pg": "bash scripts/test-pg-recovery.sh",
+    "eval:agent-ab": "tsx scripts/eval-agent-ab.mts",
+    "eval:memory-ab": "tsx scripts/eval-memory-ab.mts",
+    "eval:retrieval": "tsx scripts/eval-retrieval.mts",
+    "eval:savings": "tsx scripts/eval-task-savings.mts",
+    "branches:prune": "bash scripts/prune-merged-branches.sh",
+    lint: "biome check .",
+    format: "biome format --write .",
+    prepublishOnly: "node scripts/check-release.mjs && npm run typecheck && npm test && npm run build",
+    "eval:semantic": "tsx scripts/eval-semantic.mts"
+  },
+  keywords: [
+    "mcp",
+    "memory",
+    "agent",
+    "multi-agent",
+    "huggingface",
+    "pgvector",
+    "postgres",
+    "langgraph",
+    "claude"
+  ],
+  homepage: "https://github.com/Orquentra-Inc/CodeBuddy",
+  bugs: {
+    url: "https://github.com/Orquentra-Inc/CodeBuddy/issues"
+  },
+  dependencies: {
+    "@clack/prompts": "^1.8.1",
+    "@huggingface/inference": "^4.13.19",
+    "@modelcontextprotocol/sdk": "^1.17.5",
+    commander: "^14.0.0",
+    "drizzle-orm": "^0.45.2",
+    "js-tiktoken": "^1.0.21",
+    "p-queue": "^10.0.0",
+    "p-retry": "^8.0.1",
+    "p-timeout": "^8.1.0",
+    picocolors: "^1.1.1",
+    pino: "^10.4.0",
+    postgres: "^3.4.7",
+    yaml: "^2.9.0",
+    zod: "^4.6.7"
+  },
+  peerDependencies: {
+    "@langchain/langgraph": "^0.2.0 || ^0.3.0"
+  },
+  peerDependenciesMeta: {
+    "@langchain/langgraph": {
+      optional: true
+    }
+  },
+  devDependencies: {
+    "@biomejs/biome": "^2.5.0",
+    "@types/node": "^24.3.0",
+    "drizzle-kit": "^0.31.10",
+    tsup: "^8.5.0",
+    tsx: "^4.20.5",
+    typescript: "^5.9.2",
+    vitest: "^4.1.12"
+  },
+  optionalDependencies: {
+    "@huggingface/transformers": "^4.3.2"
+  }
+};
+
+// src/version.ts
+var VERSION = package_default.version;
+
+// src/core/memory-file-store.ts
+import { mkdir, readdir, readFile, rm, stat } from "fs/promises";
+import { dirname, join, relative, resolve, sep } from "path";
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+import { z } from "zod";
+
+// src/core/memory-lifecycle.ts
+function isEligibleMemory(fact, options = {}) {
+  if (options.namespace && fact.namespace !== options.namespace) return false;
+  if (fact.sourceDeleted || fact.supersededBy) return false;
+  if (fact.category === "incident" && fact.resolvedBy && !options.includeResolved) return false;
+  return true;
+}
+
+// src/core/memory-file-store.ts
+var FACT_CATEGORIES = ["general", "incident"];
+var INCIDENT_SEVERITIES = ["low", "medium", "high", "critical"];
+var factFrontMatterSchema = z.object({
+  schemaVersion: z.literal(1),
+  id: z.string().regex(/^fact_[a-z0-9]+$/),
+  namespace: z.string().min(1),
+  type: z.literal("fact"),
+  subject: z.string(),
+  predicate: z.string(),
+  object: z.string(),
+  /** Explicit single-valued claim identity; facts sharing it are rival assertions. */
+  propositionKey: z.string().min(1).nullable().default(null),
+  confidence: z.number().min(0).max(1),
+  createdAt: z.preprocess(
+    (value) => value instanceof Date ? value.toISOString() : value,
+    z.string().datetime()
+  ),
+  createdByAgent: z.string().nullable(),
+  sourceInteractionId: z.string().nullable(),
+  sourceDeleted: z.boolean(),
+  category: z.enum(FACT_CATEGORIES).default("general"),
+  paths: z.array(z.string().min(1)).default([]),
+  severity: z.enum(INCIDENT_SEVERITIES).nullable().default(null),
+  introducedBy: z.string().nullable().default(null),
+  resolvedBy: z.string().nullable().default(null),
+  fingerprint: z.string().regex(/^[a-f0-9]{64}$/).nullable().default(null),
+  sourcePlanId: z.string().nullable().default(null),
+  sourceSessionId: z.string().nullable().default(null),
+  verification: z.array(z.string()).default([]),
+  supersededBy: z.string().nullable().default(null),
+  /** Namespaces granted a live reference to this fact (durable form of reference shares). */
+  sharedWith: z.array(z.string().min(1)).default([])
+});
+var summaryFrontMatterSchema = z.object({
+  schemaVersion: z.literal(1),
+  id: z.string().regex(/^sum_[a-z0-9]+$/),
+  namespace: z.string().min(1),
+  type: z.literal("summary"),
+  sessionId: z.string().min(1),
+  version: z.number().int().positive(),
+  tokenCount: z.number().int().nonnegative(),
+  createdAt: z.preprocess(
+    (value) => value instanceof Date ? value.toISOString() : value,
+    z.string().datetime()
+  ),
+  createdByAgent: z.string().nullable()
+});
+var SCAN_BATCH = 64;
+var parsedFiles = /* @__PURE__ */ new Map();
+var loadedCaches = /* @__PURE__ */ new Set();
+function parseCachePath(root, directory) {
+  return join(
+    root,
+    ".codebuddy",
+    "cache",
+    `parsed-${directory.split(sep).at(-1) ?? "memory"}.json`
+  );
+}
+async function loadParseCache(root, directory) {
+  if (loadedCaches.has(directory)) return;
+  loadedCaches.add(directory);
+  try {
+    const raw = JSON.parse(await readFile(parseCachePath(root, directory), "utf8"));
+    if (raw.version !== VERSION) return;
+    for (const [name, entry] of Object.entries(raw.files)) {
+      const path = join(directory, name);
+      if (!parsedFiles.has(path)) parsedFiles.set(path, entry);
+    }
+  } catch {
+  }
+}
+async function saveParseCache(root, directory) {
+  const files = {};
+  for (const [path, entry] of parsedFiles) {
+    if (dirname(path) === directory) files[relative(directory, path)] = entry;
+  }
+  try {
+    const path = parseCachePath(root, directory);
+    await mkdir(dirname(path), { recursive: true });
+    await writeAtomic(path, JSON.stringify({ version: VERSION, files }));
+  } catch {
+  }
+}
+var MemoryFileStore = class {
+  repositoryRoot;
+  factsDirectory;
+  summariesDirectory;
+  constructor(repositoryRoot = process.cwd()) {
+    this.repositoryRoot = resolve(repositoryRoot);
+    this.factsDirectory = join(this.repositoryRoot, ".codebuddy", "memory", "facts");
+    this.summariesDirectory = join(this.repositoryRoot, ".codebuddy", "memory", "summaries");
+  }
+  async writeFact(raw) {
+    const input = redactPersisted(raw);
+    const path = this.factPath(input.id);
+    await this.prepareDirectory(this.factsDirectory);
+    await assertNoSymlinkBetween(this.repositoryRoot, dirname(path));
+    const metadata = {
+      schemaVersion: 1,
+      id: input.id,
+      namespace: input.namespace,
+      type: "fact",
+      subject: input.subject,
+      predicate: input.predicate,
+      object: input.object,
+      propositionKey: input.propositionKey,
+      confidence: input.confidence,
+      createdAt: input.createdAt,
+      createdByAgent: input.createdByAgent,
+      sourceInteractionId: input.sourceInteractionId,
+      sourceDeleted: input.sourceDeleted,
+      category: input.category,
+      paths: input.paths,
+      severity: input.severity,
+      introducedBy: input.introducedBy,
+      resolvedBy: input.resolvedBy,
+      fingerprint: input.fingerprint,
+      sourcePlanId: input.sourcePlanId,
+      sourceSessionId: input.sourceSessionId,
+      verification: input.verification,
+      supersededBy: input.supersededBy,
+      sharedWith: input.sharedWith
+    };
+    const frontMatter = stringifyYaml(stripUndefinedAndDefaultIncidentFields(metadata));
+    await writeAtomic(path, composeMarkdown(frontMatter, input.content));
+    return path;
+  }
+  async writeSummary(input) {
+    const path = this.summaryPath(input.id);
+    await this.prepareDirectory(this.summariesDirectory);
+    await assertNoSymlinkBetween(this.repositoryRoot, dirname(path));
+    const metadata = stringifyYaml({
+      schemaVersion: 1,
+      id: input.id,
+      namespace: input.namespace,
+      type: "summary",
+      sessionId: input.sessionId,
+      version: input.version,
+      tokenCount: input.tokenCount,
+      createdAt: input.createdAt,
+      createdByAgent: input.createdByAgent
+    });
+    await writeAtomic(path, composeMarkdown(metadata, input.content));
+    return path;
+  }
+  async readFact(pathOrId) {
+    return this.readFactFile(pathOrId, false);
+  }
+  /** `trusted`: the caller (scan) already proved the path is a regular file in a checked directory. */
+  async readFactFile(pathOrId, trusted) {
+    const path = pathOrId.endsWith(".md") ? this.safePath(pathOrId) : this.factPath(pathOrId);
+    if (!trusted) await assertNoSymlinkBetween(this.repositoryRoot, path);
+    const parsed = parseFrontMatter(await readFile(path, "utf8"));
+    const metadata = factFrontMatterSchema.parse(parseYaml(parsed.frontMatter));
+    return {
+      ...metadata,
+      content: parsed.content.trim(),
+      path
+    };
+  }
+  async listFacts() {
+    return (await this.scanFacts()).facts;
+  }
+  /**
+   * Parse every managed fact file. Hand-written markdown is ignored, and a
+   * schema-invalid/corrupt fact is reported in `invalid` (not thrown) so one
+   * bad file can't break recall, capture or reindexing for the whole project.
+   * Invalid files stay on disk for manual repair.
+   */
+  async scanFacts() {
+    const scan = await this.scan(
+      this.factsDirectory,
+      /^fact_[a-z0-9]+\.md$/,
+      (path, trusted) => this.readFactFile(path, trusted)
+    );
+    return { facts: scan.items, invalid: scan.invalid };
+  }
+  /**
+   * List incident facts for the namespace, ranked by severity then recency.
+   * Unlike {@link findIncidentFactsForPaths} this does not filter by path, so
+   * callers (e.g. the context engine's project bootstrap) can surface the
+   * repository's incident hotspots before any specific edit target is known.
+   */
+  async listIncidentFacts(input = {}) {
+    const incidents = (await this.listFacts()).filter(
+      (fact) => fact.category === "incident" && Boolean(fact.severity) && isEligibleMemory(fact, input)
+    );
+    return incidents.sort((left, right) => {
+      const severity = severityRank(right.severity) - severityRank(left.severity);
+      if (severity !== 0) return severity;
+      return right.createdAt.localeCompare(left.createdAt);
+    });
+  }
+  async findIncidentFactsForPaths(input) {
+    const wanted = new Set(input.paths.map(normalizeMemoryPath));
+    if (wanted.size === 0) return [];
+    return (await this.listIncidentFacts({
+      ...input.namespace !== void 0 ? { namespace: input.namespace } : {},
+      ...input.includeResolved !== void 0 ? { includeResolved: input.includeResolved } : {}
+    })).filter((fact) => fact.paths.map(normalizeMemoryPath).some((path) => wanted.has(path)));
+  }
+  async readSummary(pathOrId) {
+    const path = pathOrId.endsWith(".md") ? this.safePath(pathOrId) : this.summaryPath(pathOrId);
+    await assertNoSymlinkBetween(this.repositoryRoot, path);
+    const parsed = parseFrontMatter(await readFile(path, "utf8"));
+    return {
+      ...summaryFrontMatterSchema.parse(parseYaml(parsed.frontMatter)),
+      content: parsed.content.trim(),
+      path
+    };
+  }
+  async listSummaries() {
+    return (await this.scanSummaries()).summaries;
+  }
+  async scanSummaries() {
+    const scan = await this.scan(
+      this.summariesDirectory,
+      /^sum_[a-z0-9]+\.md$/,
+      (path) => this.readSummary(path)
+    );
+    return { summaries: scan.items, invalid: scan.invalid };
+  }
+  /**
+   * Parse every managed file in `directory`. Hot path: the prompt hook and
+   * capture scan facts several times per process, and the MCP server for its
+   * lifetime, so each parsed file is cached by path, mtime and size (a changed
+   * file is re-read, from any process) and files are read in parallel batches.
+   * The directory chain is checked for symlinks once; a `withFileTypes` entry
+   * that is a symlink is never `isFile()`, so no file escapes through one.
+   */
+  async scan(directory, managedName, read) {
+    try {
+      await this.prepareDirectory(directory);
+      await assertNoSymlinkBetween(this.repositoryRoot, directory);
+      await loadParseCache(this.repositoryRoot, directory);
+      let reparsed = false;
+      const entries = (await readdir(directory, { withFileTypes: true })).filter((entry) => entry.isFile() && managedName.test(entry.name)).sort((left, right) => left.name.localeCompare(right.name));
+      const live = new Set(entries.map((entry) => join(directory, entry.name)));
+      for (const path of [...parsedFiles.keys()]) {
+        if (dirname(path) === directory && !live.has(path)) {
+          parsedFiles.delete(path);
+          reparsed = true;
+        }
+      }
+      const outcomes = [];
+      for (let start = 0; start < entries.length; start += SCAN_BATCH) {
+        const batch = entries.slice(start, start + SCAN_BATCH);
+        outcomes.push(
+          ...await Promise.all(
+            batch.map(async (entry) => {
+              const path = join(directory, entry.name);
+              const id = entry.name.slice(0, -".md".length);
+              try {
+                const info = await stat(path);
+                const cached = parsedFiles.get(path);
+                const fresh = cached !== void 0 && cached.mtimeMs === info.mtimeMs && cached.size === info.size;
+                const item = fresh ? cached.item : await read(path, true);
+                if (!fresh) reparsed = true;
+                if (item.id !== id) {
+                  throw new Error(`file ID ${id} differs from front matter ID ${item.id}`);
+                }
+                parsedFiles.set(path, { mtimeMs: info.mtimeMs, size: info.size, item });
+                return { item: { ...item } };
+              } catch (error) {
+                parsedFiles.delete(path);
+                return {
+                  invalid: {
+                    id,
+                    path,
+                    error: error.message.split("\n")[0]?.slice(0, 300) ?? "unreadable"
+                  }
+                };
+              }
+            })
+          )
+        );
+      }
+      if (reparsed) await saveParseCache(this.repositoryRoot, directory);
+      const result = { items: [], invalid: [] };
+      for (const outcome of outcomes) {
+        if ("item" in outcome) result.items.push(outcome.item);
+        else result.invalid.push(outcome.invalid);
+      }
+      return result;
+    } catch (error) {
+      if (error.code === "ENOENT") return { items: [], invalid: [] };
+      throw error;
+    }
+  }
+  async deleteFact(id) {
+    await rm(this.factPath(id), { force: true });
+  }
+  async markIncidentResolved(id, resolvedBy) {
+    const fact = await this.readFact(id);
+    await this.writeFact(copyFact(fact, { resolvedBy }));
+  }
+  async markFactSuperseded(id, supersededBy) {
+    const fact = await this.readFact(id);
+    await this.writeFact(copyFact(fact, { supersededBy }));
+  }
+  async setFactSharedWith(id, sharedWith) {
+    const fact = await this.readFact(id);
+    await this.writeFact(copyFact(fact, { sharedWith: [...new Set(sharedWith)].sort() }));
+  }
+  /** Persist interaction deletion in Markdown before the derived DB is updated. */
+  async markSourceInteractionDeleted(namespace, sourceInteractionId) {
+    const { facts: facts2 } = await this.scanFacts();
+    for (const fact of facts2) {
+      if (fact.namespace !== namespace || fact.sourceInteractionId !== sourceInteractionId)
+        continue;
+      if (fact.sourceDeleted) continue;
+      await this.writeFact(copyFact(fact, { sourceDeleted: true }));
+    }
+  }
+  /** Persist that a fact's source interaction was forgotten, keeping its provenance id. */
+  async markFactSourceDeleted(id) {
+    const fact = await this.readFact(id);
+    await this.writeFact(copyFact(fact, { sourceDeleted: true }));
+  }
+  factPath(id) {
+    if (!/^fact_[a-z0-9]+$/.test(id)) {
+      throw new Error(`Invalid fact id: ${id}`);
+    }
+    return this.safePath(join(this.factsDirectory, `${id}.md`));
+  }
+  summaryPath(id) {
+    if (!/^sum_[a-z0-9]+$/.test(id)) throw new Error(`Invalid summary id: ${id}`);
+    return this.safePath(join(this.summariesDirectory, `${id}.md`));
+  }
+  safePath(path) {
+    const absolute = resolve(path);
+    const relativePath = relative(this.repositoryRoot, absolute);
+    if (relativePath === ".." || relativePath.startsWith(`..${sep}`) || relativePath === "") {
+      throw new Error(`Memory path escapes repository root: ${path}`);
+    }
+    return absolute;
+  }
+  async prepareDirectory(directory) {
+    await assertNoSymlinkBetween(this.repositoryRoot, dirname(directory));
+    await mkdir(directory, { recursive: true, mode: 448 });
+  }
+};
+function copyFact(fact, patch) {
+  const { path: _path, schemaVersion: _schemaVersion, type: _type, ...write } = fact;
+  return { ...write, ...patch };
+}
+function stripUndefinedAndDefaultIncidentFields(metadata) {
+  return Object.fromEntries(
+    Object.entries(metadata).filter(([key, value]) => {
+      if (value === void 0) return false;
+      if (key === "category" && value === "general") return false;
+      if ((key === "paths" || key === "sharedWith") && Array.isArray(value) && value.length === 0)
+        return false;
+      if (["severity", "introducedBy", "resolvedBy", "propositionKey"].includes(key) && (value === null || value === void 0)) {
+        return false;
+      }
+      return true;
+    })
+  );
+}
+function normalizeMemoryPath(path) {
+  return path.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+function severityRank(severity) {
+  switch (severity) {
+    case "critical":
+      return 4;
+    case "high":
+      return 3;
+    case "medium":
+      return 2;
+    case "low":
+      return 1;
+  }
+}
+
+// src/db/schema.ts
+var schema_exports = {};
+__export(schema_exports, {
+  HNSW_EF_CONSTRUCTION: () => HNSW_EF_CONSTRUCTION,
+  HNSW_M: () => HNSW_M,
+  VECTOR_DIMENSIONS: () => VECTOR_DIMENSIONS,
+  auditActionEnum: () => auditActionEnum,
+  auditLog: () => auditLog,
+  checkpoints: () => checkpoints,
+  embeddingOwnerTypeEnum: () => embeddingOwnerTypeEnum,
+  embeddingStatusEnum: () => embeddingStatusEnum,
+  embeddings: () => embeddings,
+  facts: () => facts,
+  interactionRoleEnum: () => interactionRoleEnum,
+  interactions: () => interactions,
+  memoryTypeEnum: () => memoryTypeEnum,
+  modelCallStatusEnum: () => modelCallStatusEnum,
+  modelCallTypeEnum: () => modelCallTypeEnum,
+  modelCalls: () => modelCalls,
+  namespaces: () => namespaces,
+  sessionSummaries: () => sessionSummaries,
+  shareModeEnum: () => shareModeEnum,
+  shares: () => shares
+});
+import { sql } from "drizzle-orm";
+import {
+  boolean,
+  customType,
+  index,
+  integer,
+  jsonb,
+  numeric,
+  pgEnum,
+  pgTable,
+  text,
+  timestamp,
+  uniqueIndex
+} from "drizzle-orm/pg-core";
+var VECTOR_DIMENSIONS = 384;
+var HNSW_M = 16;
+var HNSW_EF_CONSTRUCTION = 64;
+var vector = customType({
+  dataType() {
+    return `vector(${VECTOR_DIMENSIONS})`;
+  }
+});
+var memoryTypeEnum = pgEnum("memory_type", ["interaction", "fact", "summary"]);
+var interactionRoleEnum = pgEnum("interaction_role", ["user", "assistant", "system"]);
+var embeddingOwnerTypeEnum = pgEnum("embedding_owner_type", [
+  "interaction",
+  "fact",
+  "summary"
+]);
+var embeddingStatusEnum = pgEnum("embedding_status", [
+  "pending",
+  "processing",
+  "ready",
+  "failed"
+]);
+var shareModeEnum = pgEnum("share_mode", ["reference", "snapshot"]);
+var modelCallTypeEnum = pgEnum("model_call_type", ["embedding", "llm"]);
+var modelCallStatusEnum = pgEnum("model_call_status", [
+  "success",
+  "failed",
+  "timeout",
+  "rate_limited",
+  "gated",
+  "fallback"
+]);
+var auditActionEnum = pgEnum("audit_action", [
+  "remember",
+  "remember_batch",
+  "share",
+  "forget",
+  "config"
+]);
+var createdAt = timestamp("created_at", { withTimezone: true }).notNull().defaultNow();
+var updatedAt = timestamp("updated_at", { withTimezone: true }).notNull().defaultNow();
+var namespaces = pgTable(
+  "namespaces",
+  {
+    id: text("id").primaryKey(),
+    name: text("name").notNull(),
+    createdAt,
+    updatedAt
+  },
+  (table) => ({
+    nameUnique: uniqueIndex("namespaces_name_unique").on(table.name)
+  })
+);
+var interactions = pgTable(
+  "interactions",
+  {
+    id: text("id").primaryKey(),
+    namespaceId: text("namespace_id").notNull().references(() => namespaces.id, { onDelete: "cascade" }),
+    sessionId: text("session_id").notNull(),
+    role: interactionRoleEnum("role").notNull().default("user"),
+    content: text("content").notNull(),
+    contentHash: text("content_hash").notNull(),
+    tokenCount: integer("token_count").notNull().default(0),
+    createdByAgent: text("created_by_agent"),
+    createdAt
+  },
+  (table) => ({
+    namespaceContentHashUnique: uniqueIndex("interactions_namespace_content_hash_unique").on(
+      table.namespaceId,
+      table.contentHash
+    ),
+    namespaceSessionCreatedIdx: index("interactions_namespace_session_created_idx").on(
+      table.namespaceId,
+      table.sessionId,
+      table.createdAt
+    )
+  })
+);
+var sessionSummaries = pgTable(
+  "session_summaries",
+  {
+    id: text("id").primaryKey(),
+    namespaceId: text("namespace_id").notNull().references(() => namespaces.id, { onDelete: "cascade" }),
+    sessionId: text("session_id").notNull(),
+    content: text("content").notNull(),
+    version: integer("version").notNull().default(1),
+    tokenCount: integer("token_count").notNull().default(0),
+    createdByAgent: text("created_by_agent"),
+    /** See facts.fileBacked. */
+    fileBacked: boolean("file_backed").notNull().default(false),
+    createdAt
+  },
+  (table) => ({
+    namespaceSessionVersionIdx: index("session_summaries_namespace_session_version_idx").on(
+      table.namespaceId,
+      table.sessionId,
+      table.version
+    )
+  })
+);
+var facts = pgTable(
+  "facts",
+  {
+    id: text("id").primaryKey(),
+    namespaceId: text("namespace_id").notNull().references(() => namespaces.id, { onDelete: "cascade" }),
+    subject: text("subject").notNull(),
+    predicate: text("predicate").notNull(),
+    object: text("object").notNull(),
+    propositionKey: text("proposition_key"),
+    content: text("content").notNull(),
+    contentHash: text("content_hash").notNull(),
+    confidence: numeric("confidence", { precision: 5, scale: 4 }).notNull().default("1"),
+    /**
+     * Historical provenance only — deliberately not a foreign key. Interactions
+     * are ephemeral DB rows; Markdown facts must re-import after a rebuild that
+     * lost them, and the ID must survive so `sourceDeleted` can be tracked.
+     */
+    sourceInteractionId: text("source_interaction_id"),
+    sourceDeleted: boolean("source_deleted").notNull().default(false),
+    supersededBy: text("superseded_by"),
+    /**
+     * True once a reindex imported this row from its Markdown file. Only such
+     * rows are deleted when the file disappears; DB-only legacy rows are kept.
+     */
+    fileBacked: boolean("file_backed").notNull().default(false),
+    embeddingModel: text("embedding_model"),
+    createdByAgent: text("created_by_agent"),
+    createdAt,
+    updatedAt
+  },
+  (table) => ({
+    namespaceContentHashUnique: uniqueIndex("facts_namespace_content_hash_unique").on(
+      table.namespaceId,
+      table.contentHash
+    ),
+    namespaceSubjectIdx: index("facts_namespace_subject_idx").on(table.namespaceId, table.subject),
+    sourceInteractionIdx: index("facts_source_interaction_idx").on(table.sourceInteractionId)
+  })
+);
+var embeddings = pgTable(
+  "embeddings",
+  {
+    id: text("id").primaryKey(),
+    namespaceId: text("namespace_id").notNull().references(() => namespaces.id, { onDelete: "cascade" }),
+    ownerType: embeddingOwnerTypeEnum("owner_type").notNull(),
+    ownerId: text("owner_id").notNull(),
+    vector: vector("vector").notNull(),
+    embeddingModel: text("embedding_model").notNull(),
+    embeddingSpace: text("embedding_space"),
+    status: embeddingStatusEnum("status").notNull().default("pending"),
+    attempts: integer("attempts").notNull().default(0),
+    lastError: text("last_error"),
+    /** Lease deadline while status='processing'; null otherwise. */
+    leaseUntil: timestamp("lease_until", { withTimezone: true }),
+    leaseToken: text("lease_token"),
+    createdAt,
+    updatedAt
+  },
+  (table) => ({
+    ownerUnique: uniqueIndex("embeddings_owner_unique").on(table.ownerType, table.ownerId),
+    namespaceModelStatusIdx: index("embeddings_namespace_model_status_idx").on(
+      table.namespaceId,
+      table.embeddingModel,
+      table.status
+    ),
+    namespaceSpaceStatusIdx: index("embeddings_namespace_space_status_idx").on(
+      table.namespaceId,
+      table.embeddingSpace,
+      table.status
+    ),
+    vectorHnswIdx: index("embeddings_vector_hnsw_idx").using(
+      "hnsw",
+      sql`${table.vector} vector_cosine_ops`
+    )
+  })
+);
+var shares = pgTable(
+  "shares",
+  {
+    id: text("id").primaryKey(),
+    fromNamespaceId: text("from_namespace_id").notNull().references(() => namespaces.id, { onDelete: "cascade" }),
+    toNamespaceId: text("to_namespace_id").notNull().references(() => namespaces.id, { onDelete: "cascade" }),
+    sourceFactId: text("source_fact_id").notNull().references(() => facts.id, { onDelete: "cascade" }),
+    snapshotFactId: text("snapshot_fact_id").references(() => facts.id, { onDelete: "set null" }),
+    mode: shareModeEnum("mode").notNull().default("reference"),
+    tombstoned: boolean("tombstoned").notNull().default(false),
+    createdByAgent: text("created_by_agent"),
+    createdAt
+  },
+  (table) => ({
+    shareUnique: uniqueIndex("shares_target_source_unique").on(
+      table.toNamespaceId,
+      table.sourceFactId,
+      table.mode
+    ),
+    fromNamespaceIdx: index("shares_from_namespace_idx").on(table.fromNamespaceId)
+  })
+);
+var checkpoints = pgTable(
+  "checkpoints",
+  {
+    id: text("id").primaryKey(),
+    namespaceId: text("namespace_id").notNull().references(() => namespaces.id, { onDelete: "cascade" }),
+    threadId: text("thread_id").notNull(),
+    checkpointId: text("checkpoint_id").notNull(),
+    parentId: text("parent_id"),
+    channelValues: jsonb("channel_values").notNull().default(sql`'{}'::jsonb`),
+    metadata: jsonb("metadata").notNull().default(sql`'{}'::jsonb`),
+    createdAt
+  },
+  (table) => ({
+    checkpointUnique: uniqueIndex("checkpoints_thread_checkpoint_unique").on(
+      table.namespaceId,
+      table.threadId,
+      table.checkpointId
+    )
+  })
+);
+var modelCalls = pgTable(
+  "model_calls",
+  {
+    id: text("id").primaryKey(),
+    namespaceId: text("namespace_id").references(() => namespaces.id, { onDelete: "set null" }),
+    model: text("model").notNull(),
+    type: modelCallTypeEnum("type").notNull(),
+    latencyMs: integer("latency_ms"),
+    tokens: integer("tokens"),
+    status: modelCallStatusEnum("status").notNull(),
+    error: text("error"),
+    metadata: jsonb("metadata").notNull().default(sql`'{}'::jsonb`),
+    createdAt
+  },
+  (table) => ({
+    modelCreatedIdx: index("model_calls_model_created_idx").on(table.model, table.createdAt),
+    namespaceCreatedIdx: index("model_calls_namespace_created_idx").on(
+      table.namespaceId,
+      table.createdAt
+    )
+  })
+);
+var auditLog = pgTable(
+  "audit_log",
+  {
+    id: text("id").primaryKey(),
+    namespaceId: text("namespace_id").references(() => namespaces.id, { onDelete: "set null" }),
+    action: auditActionEnum("action").notNull(),
+    entityType: text("entity_type").notNull(),
+    entityId: text("entity_id"),
+    createdByAgent: text("created_by_agent"),
+    metadata: jsonb("metadata").notNull().default(sql`'{}'::jsonb`),
+    createdAt
+  },
+  (table) => ({
+    namespaceActionCreatedIdx: index("audit_log_namespace_action_created_idx").on(
+      table.namespaceId,
+      table.action,
+      table.createdAt
+    )
+  })
+);
+
+// src/core/memory-search.ts
+function candidateLimit(limit) {
+  if (!Number.isFinite(limit)) return 256;
+  return Math.max(1, Math.min(1024, Math.trunc(limit)));
+}
+function validSearchVector(vector2) {
+  return vector2.length === VECTOR_DIMENSIONS && vector2.every((value) => Number.isFinite(Math.fround(value))) && vector2.some((value) => value !== 0);
+}
+var QUERY_STOPWORDS = /* @__PURE__ */ new Set([
+  "a",
+  "about",
+  "after",
+  "again",
+  "all",
+  "also",
+  "always",
+  "an",
+  "and",
+  "any",
+  "are",
+  "as",
+  "at",
+  "back",
+  "be",
+  "been",
+  "before",
+  "being",
+  "but",
+  "by",
+  "can",
+  "could",
+  "did",
+  "do",
+  "does",
+  "done",
+  "each",
+  "even",
+  "ever",
+  "for",
+  "from",
+  "get",
+  "gets",
+  "got",
+  "had",
+  "has",
+  "have",
+  "here",
+  "how",
+  "i",
+  "if",
+  "in",
+  "into",
+  "is",
+  "it",
+  "its",
+  "just",
+  "like",
+  "make",
+  "me",
+  "more",
+  "most",
+  "my",
+  "never",
+  "no",
+  "not",
+  "now",
+  "of",
+  "on",
+  "only",
+  "or",
+  "other",
+  "our",
+  "out",
+  "over",
+  "please",
+  "really",
+  "same",
+  "should",
+  "so",
+  "some",
+  "sometimes",
+  "still",
+  "such",
+  "than",
+  "that",
+  "the",
+  "their",
+  "them",
+  "then",
+  "there",
+  "these",
+  "they",
+  "this",
+  "those",
+  "through",
+  "to",
+  "too",
+  "under",
+  "up",
+  "us",
+  "very",
+  "was",
+  "we",
+  "were",
+  "what",
+  "when",
+  "where",
+  "which",
+  "while",
+  "who",
+  "why",
+  "will",
+  "with",
+  "would",
+  "yet",
+  "you",
+  "your"
+]);
+function lexicalTerms(query) {
+  return [
+    ...new Set(
+      query.slice(0, 4096).toLowerCase().match(/[\p{L}\p{N}_]+/gu) ?? []
+    )
+  ].filter((term) => !QUERY_STOPWORDS.has(term)).slice(0, 32).map((term) => term.slice(0, 64));
+}
+var CLAIM_BOILERPLATE = /* @__PURE__ */ new Set([
+  "decided",
+  "decide",
+  "decision",
+  "made",
+  "use",
+  "uses",
+  "used",
+  "using",
+  "now",
+  "going",
+  "will"
+]);
+function termOverlap(a, b) {
+  const terms = (text2) => new Set(
+    (text2.toLowerCase().match(/[\p{L}\p{N}_]+/gu) ?? []).filter(
+      (term) => !QUERY_STOPWORDS.has(term) && !CLAIM_BOILERPLATE.has(term)
+    )
+  );
+  const left = terms(a);
+  const right = terms(b);
+  if (left.size === 0 || right.size === 0) return 0;
+  let shared = 0;
+  for (const term of left) if (right.has(term)) shared += 1;
+  return shared / (left.size + right.size - shared);
+}
+
+export {
+  isEligibleMemory,
+  namespaces,
+  interactions,
+  sessionSummaries,
+  facts,
+  embeddings,
+  shares,
+  modelCalls,
+  auditLog,
+  schema_exports,
+  candidateLimit,
+  validSearchVector,
+  lexicalTerms,
+  termOverlap,
+  VERSION,
+  FACT_CATEGORIES,
+  INCIDENT_SEVERITIES,
+  MemoryFileStore
+};
+//# sourceMappingURL=chunk-S6VEG4S2.js.map