@orquentra/codebuddy 2.6.0 → 2.7.0

package/dist/chunk-JUAFCLRB.js

@@ -0,0 +1,1014 @@
+import {
+  redactPersisted
+} from "./chunk-AL6VBTNA.js";
+import {
+  assertNoSymlinkBetween,
+  composeMarkdown,
+  parseFrontMatter,
+  writeAtomic
+} from "./chunk-CG5B3LYG.js";
+import {
+  __export
+} from "./chunk-PZ5AY32C.js";
+
+// package.json
+var package_default = {
+  name: "@orquentra/codebuddy",
+  version: "2.7.0",
+  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),
+  /** The caller's `remember` idempotency key, so a retry after reindex dedupes. */
+  idempotencyKey: z.string().min(1).max(200).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,
+      idempotencyKey: input.idempotencyKey,
+      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", "idempotencyKey"].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"),
+    /** Kept apart from content_hash so a reindex (which recomputes the hash) keeps it. */
+    idempotencyKey: text("idempotency_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),
+    namespaceIdempotencyIdx: index("facts_namespace_idempotency_idx").on(
+      table.namespaceId,
+      table.idempotencyKey
+    ),
+    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 GENERIC_TERMS = new Set(
+  "add added adding bug build call change changed changes check code config configure configuration create data default delete error errors feature file files fix fixed handle issue line load logic new option options problem project read remove result return run running save set setting settings show step support test tests thing time update updated use used value values version want way work works write".split(" ")
+);
+var RARE_TERM_SHARE = 5e-3;
+var RARE_TERM_MIN_DF = 2;
+function admitsLexically(shared, documentFrequency, corpusSize) {
+  const specific = shared.filter((term) => !GENERIC_TERMS.has(term));
+  if (specific.length >= 2) return true;
+  const rare = Math.max(RARE_TERM_MIN_DF, Math.floor(RARE_TERM_SHARE * corpusSize));
+  return specific.some((term) => (documentFrequency.get(term) ?? 0) <= rare);
+}
+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,
+  admitsLexically,
+  termOverlap,
+  VERSION,
+  FACT_CATEGORIES,
+  INCIDENT_SEVERITIES,
+  MemoryFileStore
+};
+//# sourceMappingURL=chunk-JUAFCLRB.js.map