@orquentra/codebuddy 2.4.0 → 2.5.0

package/dist/chunk-JDZ3VK26.js

@@ -0,0 +1,4006 @@
+import {
+  REDACTED,
+  redactPersisted
+} from "./chunk-GDJH7XJC.js";
+import {
+  clampBudgetForCallerModel,
+  computeContentHash,
+  computeFactHash,
+  countTokens,
+  generateEntityId,
+  generateSessionId
+} from "./chunk-4BYGTEJT.js";
+import {
+  OpenRouterEmbeddingProvider
+} from "./chunk-KYK6RPAJ.js";
+import {
+  LocalModelProvider
+} from "./chunk-3XYQGFPB.js";
+import {
+  DEFAULT_CLOUD_EMBEDDING_MODELS,
+  DEFAULT_EMBEDDING_MODELS,
+  DEFAULT_LLM_MODELS,
+  EMBEDDING_DIMENSIONS,
+  assertCompatibleEmbeddingModels,
+  getModelDefinition
+} from "./chunk-JMWJ7V6Y.js";
+import {
+  MISSING_DATABASE_URL,
+  assertNoSymlinkBetween,
+  checkConfigPermissions,
+  checkProjectScaffold,
+  composeMarkdown,
+  defaultNamespaceForCwd,
+  loadRuntimeConfig,
+  parseFrontMatter,
+  readConfigFile,
+  redactSecrets,
+  writeAtomic
+} from "./chunk-776EQXDV.js";
+import {
+  __export
+} from "./chunk-PZ5AY32C.js";
+
+// 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/db/bootstrap.ts
+async function enablePgvector(sql3) {
+  await sql3`create extension if not exists vector`;
+}
+async function checkPgvector(sql3) {
+  const result = await sql3`
+    select extversion from pg_extension where extname = 'vector'
+  `;
+  return {
+    available: result.length > 0,
+    installedVersion: result[0]?.extversion ?? null
+  };
+}
+async function bootstrapDatabase(sql3) {
+  await enablePgvector(sql3);
+  return checkPgvector(sql3);
+}
+
+// src/db/client.ts
+import { drizzle } from "drizzle-orm/postgres-js";
+import postgres from "postgres";
+function createDatabaseClient(config) {
+  const sql3 = postgres(config.postgresUrl, {
+    max: config.maxConnections ?? 10,
+    ...config.connectTimeoutSeconds !== void 0 ? { connect_timeout: config.connectTimeoutSeconds } : {},
+    // postgres.js logs NOTICE messages (e.g. "extension already exists,
+    // skipping") to stdout by default. Over the MCP stdio transport stdout
+    // carries JSON-RPC, so any notice corrupts the stream and the client
+    // reports "Unexpected token … is not valid JSON". Route notices to
+    // stderr instead, where logs belong.
+    onnotice: (notice) => {
+      process.stderr.write(`${JSON.stringify(notice)}
+`);
+    }
+  });
+  return {
+    sql: sql3,
+    db: drizzle(sql3, { schema: schema_exports }),
+    async close() {
+      await sql3.end();
+    }
+  };
+}
+async function pingDatabase(client) {
+  const result = await client.sql`select 1 as ok`;
+  return result[0]?.ok === 1;
+}
+
+// src/db/migrator.ts
+import { existsSync } from "fs";
+import { dirname, resolve } from "path";
+import { fileURLToPath } from "url";
+import { migrate } from "drizzle-orm/postgres-js/migrator";
+function resolveMigrationsFolder() {
+  const here = dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    // Co-located (src/db/ -> src/db/migrations)
+    resolve(here, "migrations"),
+    // Built dist (dist/<chunk>.js -> ../src/db/migrations relative paths)
+    resolve(here, "..", "src", "db", "migrations"),
+    resolve(here, "..", "..", "src", "db", "migrations"),
+    resolve(here, "..", "..", "..", "src", "db", "migrations"),
+    resolve(here, "..", "..", "..", "..", "src", "db", "migrations"),
+    // CWD fallback (developer running from repo root)
+    resolve(process.cwd(), "src", "db", "migrations")
+  ];
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) return candidate;
+  }
+  throw new Error(
+    `Could not locate migrations folder. Tried:
+  ${candidates.join("\n  ")}
+If this is an npm-installed package, make sure src/db/migrations was included in the tarball.`
+  );
+}
+async function runMigrations(client) {
+  const migrationsFolder = resolveMigrationsFolder();
+  await migrate(client.db, { migrationsFolder });
+}
+
+// src/db/repository.ts
+import { AsyncLocalStorage } from "async_hooks";
+import { createHash } from "crypto";
+import { and, desc, eq, inArray, isNull, lt, ne, or, sql as sql2 } from "drizzle-orm";
+
+// 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));
+}
+
+// src/providers/embedding-space.ts
+function embeddingSpace(response) {
+  const space = {
+    model: response.model,
+    revision: response.revision ?? "unversioned",
+    schema: response.schema ?? "provider-v1",
+    dimensions: response.dimensions
+  };
+  if (!space.model || !space.revision || !space.schema || !Number.isSafeInteger(space.dimensions) || space.dimensions <= 0) {
+    throw new Error("Invalid embedding space identity.");
+  }
+  return space;
+}
+function embeddingSpaceKey(space) {
+  return JSON.stringify([space.model, space.revision, space.schema, space.dimensions]);
+}
+function validEmbeddingVector(vector2, dimensions) {
+  return dimensions > 0 && vector2.length === dimensions && vector2.every(Number.isFinite);
+}
+function validateEmbeddingResponse(response, count) {
+  embeddingSpace(response);
+  if (response.vectors.length !== count || response.vectors.some((vector2) => !validEmbeddingVector(vector2, response.dimensions))) {
+    throw new Error("Provider returned invalid embedding dimensions, values, or batch size.");
+  }
+}
+
+// src/db/repository.ts
+var PostgresMemoryRepository = class {
+  client;
+  sessionTransaction = new AsyncLocalStorage();
+  constructor(client) {
+    this.client = client;
+  }
+  get db() {
+    return this.sessionTransaction.getStore() ?? this.client.db;
+  }
+  async ensureNamespace(name) {
+    const existing = await this.getNamespaceByName(name);
+    if (existing) return existing;
+    const id = generateEntityId("ns");
+    await this.db.insert(namespaces).values({ id, name }).onConflictDoNothing({ target: namespaces.name });
+    const row = await this.getNamespaceByName(name);
+    if (!row) throw new Error(`Failed to ensure namespace ${name}.`);
+    return row;
+  }
+  async getNamespaceByName(name) {
+    const rows = await this.db.select({ id: namespaces.id, name: namespaces.name }).from(namespaces).where(eq(namespaces.name, name)).limit(1);
+    return rows[0] ?? null;
+  }
+  async withSessionLock(namespaceId, sessionId, fn) {
+    const [k1, k2] = advisoryLockKeys(namespaceId, sessionId);
+    return this.client.db.transaction(async (tx) => {
+      await tx.execute(sql2`select pg_advisory_xact_lock(${k1}, ${k2})`);
+      return this.sessionTransaction.run(tx, fn);
+    });
+  }
+  async writeInteraction(input) {
+    return this.db.transaction(async (tx) => {
+      const existing = await tx.select({ id: interactions.id, sessionId: interactions.sessionId }).from(interactions).where(
+        and(
+          eq(interactions.namespaceId, input.interaction.namespaceId),
+          eq(interactions.contentHash, input.interaction.contentHash)
+        )
+      ).limit(1);
+      const existingRow = existing[0];
+      if (existingRow) {
+        return {
+          id: existingRow.id,
+          embeddingId: "",
+          sessionId: existingRow.sessionId,
+          deduplicated: true
+        };
+      }
+      await tx.insert(interactions).values({
+        id: input.interaction.id,
+        namespaceId: input.interaction.namespaceId,
+        sessionId: input.interaction.sessionId,
+        content: input.interaction.content,
+        contentHash: input.interaction.contentHash,
+        tokenCount: input.interaction.tokenCount,
+        createdByAgent: input.interaction.createdByAgent ?? null
+      });
+      await tx.insert(embeddings).values({
+        id: input.embedding.id,
+        namespaceId: input.embedding.namespaceId,
+        ownerType: input.embedding.ownerType,
+        ownerId: input.embedding.ownerId,
+        vector: zeroVectorLiteral(),
+        embeddingModel: input.embedding.embeddingModel,
+        status: "pending"
+      });
+      await tx.insert(auditLog).values(toAuditRow(input.audit));
+      return {
+        id: input.interaction.id,
+        embeddingId: input.embedding.id,
+        sessionId: input.interaction.sessionId,
+        deduplicated: false
+      };
+    });
+  }
+  async writeFact(input) {
+    return this.db.transaction(async (tx) => {
+      const existing = await tx.select({ id: facts.id }).from(facts).where(
+        and(
+          eq(facts.namespaceId, input.fact.namespaceId),
+          eq(facts.contentHash, input.fact.contentHash)
+        )
+      ).limit(1);
+      const existingRow = existing[0];
+      if (existingRow) {
+        return {
+          id: existingRow.id,
+          embeddingId: "",
+          sessionId: "",
+          deduplicated: true
+        };
+      }
+      const sameId = await tx.select({ id: facts.id }).from(facts).where(eq(facts.id, input.fact.id)).limit(1);
+      if (sameId[0]) {
+        return { id: sameId[0].id, embeddingId: "", sessionId: "", deduplicated: true };
+      }
+      await tx.insert(facts).values({
+        id: input.fact.id,
+        namespaceId: input.fact.namespaceId,
+        subject: input.fact.subject,
+        predicate: input.fact.predicate,
+        object: input.fact.object,
+        content: input.fact.content,
+        contentHash: input.fact.contentHash,
+        propositionKey: input.fact.propositionKey ?? null,
+        confidence: String(input.fact.confidence ?? 1),
+        sourceDeleted: input.fact.sourceDeleted ?? false,
+        supersededBy: input.fact.supersededBy ?? null,
+        ...input.fact.createdAt ? { createdAt: input.fact.createdAt } : {},
+        sourceInteractionId: input.fact.sourceInteractionId ?? null,
+        createdByAgent: input.fact.createdByAgent ?? null
+      });
+      await tx.insert(embeddings).values({
+        id: input.embedding.id,
+        namespaceId: input.embedding.namespaceId,
+        ownerType: input.embedding.ownerType,
+        ownerId: input.embedding.ownerId,
+        vector: zeroVectorLiteral(),
+        embeddingModel: input.embedding.embeddingModel,
+        status: "pending"
+      });
+      await tx.insert(auditLog).values(toAuditRow(input.audit));
+      return {
+        id: input.fact.id,
+        embeddingId: input.embedding.id,
+        sessionId: "",
+        deduplicated: false
+      };
+    });
+  }
+  async writeSummary(input) {
+    return this.db.transaction(async (tx) => {
+      const existing = await tx.select({ id: sessionSummaries.id, sessionId: sessionSummaries.sessionId }).from(sessionSummaries).where(eq(sessionSummaries.id, input.summary.id)).limit(1);
+      const existingRow = existing[0];
+      if (existingRow) {
+        return {
+          id: existingRow.id,
+          embeddingId: "",
+          sessionId: existingRow.sessionId,
+          deduplicated: true
+        };
+      }
+      await tx.insert(sessionSummaries).values({
+        id: input.summary.id,
+        namespaceId: input.summary.namespaceId,
+        sessionId: input.summary.sessionId,
+        content: input.summary.content,
+        version: input.summary.version ?? 1,
+        tokenCount: input.summary.tokenCount,
+        createdByAgent: input.summary.createdByAgent ?? null
+      });
+      await tx.insert(embeddings).values({
+        id: input.embedding.id,
+        namespaceId: input.embedding.namespaceId,
+        ownerType: input.embedding.ownerType,
+        ownerId: input.embedding.ownerId,
+        vector: zeroVectorLiteral(),
+        embeddingModel: input.embedding.embeddingModel,
+        status: "pending"
+      });
+      await tx.insert(auditLog).values(toAuditRow(input.audit));
+      return {
+        id: input.summary.id,
+        embeddingId: input.embedding.id,
+        sessionId: input.summary.sessionId,
+        deduplicated: false
+      };
+    });
+  }
+  async upsertFactFromFile(input) {
+    const fact = input.fact;
+    return this.db.transaction(async (tx) => {
+      const [existing] = await tx.select().from(facts).where(eq(facts.id, fact.id)).for("update").limit(1);
+      if (existing && existing.namespaceId !== fact.namespaceId) {
+        throw new Error(`fact ${fact.id} already belongs to another namespace`);
+      }
+      const [duplicate] = await tx.select({ id: facts.id }).from(facts).where(
+        and(
+          eq(facts.namespaceId, fact.namespaceId),
+          eq(facts.contentHash, fact.contentHash),
+          ne(facts.id, fact.id)
+        )
+      ).limit(1);
+      if (duplicate) throw new Error(`content duplicates fact ${duplicate.id}`);
+      const values = {
+        subject: fact.subject,
+        predicate: fact.predicate,
+        object: fact.object,
+        content: fact.content,
+        contentHash: fact.contentHash,
+        confidence: String(fact.confidence),
+        sourceInteractionId: fact.sourceInteractionId ?? null,
+        sourceDeleted: fact.sourceDeleted,
+        supersededBy: fact.supersededBy,
+        propositionKey: fact.propositionKey ?? null,
+        createdByAgent: fact.createdByAgent ?? null,
+        createdAt: fact.createdAt,
+        fileBacked: true
+      };
+      if (!existing) {
+        await tx.insert(facts).values({ id: fact.id, namespaceId: fact.namespaceId, ...values });
+        await upsertPendingEmbedding(tx, input.embedding, true);
+        await tx.insert(auditLog).values(toAuditRow(input.audit));
+        return { status: "inserted" };
+      }
+      const contentChanged = existing.content !== fact.content;
+      const metadataChanged = existing.subject !== values.subject || existing.predicate !== values.predicate || existing.object !== values.object || Number(existing.confidence) !== Number(fact.confidence.toFixed(4)) || existing.sourceInteractionId !== values.sourceInteractionId || existing.sourceDeleted !== values.sourceDeleted || existing.supersededBy !== values.supersededBy || existing.propositionKey !== values.propositionKey || existing.createdByAgent !== values.createdByAgent || existing.createdAt.getTime() !== values.createdAt.getTime();
+      if (contentChanged || metadataChanged || !existing.fileBacked) {
+        await tx.update(facts).set({ ...values, updatedAt: sql2`now()` }).where(and(eq(facts.namespaceId, fact.namespaceId), eq(facts.id, fact.id)));
+      }
+      await upsertPendingEmbedding(tx, input.embedding, contentChanged);
+      if (!contentChanged && !metadataChanged) return { status: "unchanged" };
+      await tx.insert(auditLog).values(toAuditRow(input.audit));
+      return { status: "updated" };
+    });
+  }
+  async upsertSummaryFromFile(input) {
+    const summary = input.summary;
+    return this.db.transaction(async (tx) => {
+      const [existing] = await tx.select().from(sessionSummaries).where(eq(sessionSummaries.id, summary.id)).for("update").limit(1);
+      if (existing && existing.namespaceId !== summary.namespaceId) {
+        throw new Error(`summary ${summary.id} already belongs to another namespace`);
+      }
+      const values = {
+        sessionId: summary.sessionId,
+        content: summary.content,
+        version: summary.version ?? 1,
+        tokenCount: summary.tokenCount,
+        createdByAgent: summary.createdByAgent ?? null,
+        createdAt: summary.createdAt,
+        fileBacked: true
+      };
+      if (!existing) {
+        await tx.insert(sessionSummaries).values({
+          id: summary.id,
+          namespaceId: summary.namespaceId,
+          ...values
+        });
+        await upsertPendingEmbedding(tx, input.embedding, true);
+        await tx.insert(auditLog).values(toAuditRow(input.audit));
+        return { status: "inserted" };
+      }
+      const contentChanged = existing.content !== summary.content;
+      const metadataChanged = existing.sessionId !== values.sessionId || existing.version !== values.version || existing.tokenCount !== values.tokenCount || existing.createdByAgent !== values.createdByAgent || existing.createdAt.getTime() !== values.createdAt.getTime();
+      if (contentChanged || metadataChanged || !existing.fileBacked) {
+        await tx.update(sessionSummaries).set(values).where(
+          and(
+            eq(sessionSummaries.namespaceId, summary.namespaceId),
+            eq(sessionSummaries.id, summary.id)
+          )
+        );
+      }
+      await upsertPendingEmbedding(tx, input.embedding, contentChanged);
+      if (!contentChanged && !metadataChanged) return { status: "unchanged" };
+      await tx.insert(auditLog).values(toAuditRow(input.audit));
+      return { status: "updated" };
+    });
+  }
+  async listFileBackedIds(namespaceId) {
+    const [factRows, summaryRows] = await Promise.all([
+      this.db.select({ id: facts.id }).from(facts).where(and(eq(facts.namespaceId, namespaceId), eq(facts.fileBacked, true))),
+      this.db.select({ id: sessionSummaries.id }).from(sessionSummaries).where(
+        and(eq(sessionSummaries.namespaceId, namespaceId), eq(sessionSummaries.fileBacked, true))
+      )
+    ]);
+    return { facts: factRows.map((row) => row.id), summaries: summaryRows.map((row) => row.id) };
+  }
+  /**
+   * Claim up to `limit` embeddable jobs.
+   *
+   * A claim is a LEASE, not just a row lock: claimed rows move to
+   * status='processing' with a `lease_until` deadline, so protection survives
+   * the committing transaction. Concurrent workers (e.g. Claude Desktop and
+   * Codex both running `codebuddy serve`) therefore never process the same
+   * item twice. Expired leases are re-claimable, so a crashed worker's work is
+   * picked up again instead of being stuck forever.
+   */
+  async claimPendingEmbeddings(limit) {
+    const rows = await this.client.sql`
+      with claimed as (
+        select id from embeddings
+        where status = 'pending'
+           or (status = 'processing' and (lease_until is null or lease_until < now()))
+        order by created_at asc
+        for update skip locked
+        limit ${limit}
+      )
+      update embeddings e
+      set status = 'processing',
+          lease_until = now() + interval '120 seconds',
+          lease_token = ${generateEntityId("lease")},
+          updated_at = now()
+      from claimed
+      where e.id = claimed.id
+      returning
+        e.id,
+        e.lease_token,
+        e.namespace_id,
+        e.owner_type,
+        e.owner_id,
+        e.embedding_model,
+        e.attempts,
+        coalesce(
+          (select content from interactions where id = e.owner_id),
+          (select content from facts where id = e.owner_id),
+          (select content from session_summaries where id = e.owner_id)
+        ) as content
+    `;
+    return rows.map((row) => ({
+      id: row.id,
+      leaseToken: row.lease_token,
+      leaseMs: 12e4,
+      namespaceId: row.namespace_id,
+      ownerType: row.owner_type,
+      ownerId: row.owner_id,
+      embeddingModel: row.embedding_model,
+      attempts: row.attempts,
+      content: row.content ?? ""
+    }));
+  }
+  async renewEmbeddingLease(id, leaseToken) {
+    const rows = await this.db.update(embeddings).set({ leaseUntil: sql2`now() + interval '120 seconds'` }).where(
+      and(
+        eq(embeddings.id, id),
+        eq(embeddings.leaseToken, leaseToken),
+        eq(embeddings.status, "processing"),
+        sql2`${embeddings.leaseUntil} > now()`
+      )
+    ).returning({ id: embeddings.id });
+    return rows.length > 0;
+  }
+  async markEmbeddingReady(id, leaseToken, vector2, model, space) {
+    const literal = `[${vector2.join(",")}]`;
+    const rows = await this.db.update(embeddings).set({
+      status: "ready",
+      vector: literal,
+      embeddingModel: model,
+      embeddingSpace: space ?? embeddingSpaceKey(embeddingSpace({ model, dimensions: vector2.length })),
+      lastError: null,
+      leaseUntil: null,
+      leaseToken: null,
+      updatedAt: sql2`now()`
+    }).where(
+      and(
+        eq(embeddings.id, id),
+        eq(embeddings.leaseToken, leaseToken),
+        eq(embeddings.status, "processing"),
+        sql2`${embeddings.leaseUntil} > now()`
+      )
+    ).returning({ id: embeddings.id });
+    return rows.length > 0;
+  }
+  /**
+   * Record a failure. Below `maxAttempts`, the row goes back to
+   * 'processing' with an exponentially growing lease (2s · 2^(attempts-1),
+   * capped at 60s) that acts as a retry backoff timer — a rate-limited
+   * endpoint is no longer hammered every poll tick. At `maxAttempts` the job
+   * is parked as 'failed'.
+   */
+  async markEmbeddingFailed(id, leaseToken, error, attempts, options) {
+    const maxAttempts = options?.maxAttempts ?? 5;
+    const backoffSeconds = Math.min(60, 2 ** Math.max(0, attempts - 1));
+    const rows = await this.db.update(embeddings).set({
+      status: sql2`case when ${attempts} >= ${maxAttempts} then 'failed'::embedding_status else 'processing'::embedding_status end`,
+      leaseUntil: sql2`case when ${attempts} >= ${maxAttempts} then null else now() + (${backoffSeconds} || ' seconds')::interval end`,
+      leaseToken: null,
+      attempts,
+      lastError: error,
+      updatedAt: sql2`now()`
+    }).where(
+      and(
+        eq(embeddings.id, id),
+        eq(embeddings.leaseToken, leaseToken),
+        eq(embeddings.status, "processing"),
+        sql2`${embeddings.leaseUntil} > now()`
+      )
+    ).returning({ id: embeddings.id });
+    return rows.length > 0;
+  }
+  async getEmbeddingStatus(id) {
+    const rows = await this.db.select({
+      id: embeddings.id,
+      status: embeddings.status,
+      attempts: embeddings.attempts,
+      lastError: embeddings.lastError
+    }).from(embeddings).where(eq(embeddings.id, id)).limit(1);
+    const row = rows[0];
+    if (!row) return null;
+    return {
+      id: row.id,
+      status: row.status,
+      attempts: row.attempts,
+      lastError: row.lastError
+    };
+  }
+  async shareReference(input) {
+    await this.db.insert(shares).values({
+      id: input.id,
+      fromNamespaceId: input.fromNamespaceId,
+      toNamespaceId: input.toNamespaceId,
+      sourceFactId: input.sourceFactId,
+      mode: "reference",
+      createdByAgent: input.createdByAgent ?? null
+    }).onConflictDoUpdate({
+      target: [shares.toNamespaceId, shares.sourceFactId, shares.mode],
+      set: { tombstoned: false }
+    });
+  }
+  async revokeShares(fromNamespaceId, toNamespaceId, factIds) {
+    if (factIds.length === 0) return 0;
+    const revoked = await this.db.update(shares).set({ tombstoned: true }).where(
+      and(
+        eq(shares.fromNamespaceId, fromNamespaceId),
+        eq(shares.toNamespaceId, toNamespaceId),
+        eq(shares.mode, "reference"),
+        eq(shares.tombstoned, false),
+        inArray(shares.sourceFactId, factIds)
+      )
+    ).returning({ id: shares.id });
+    return revoked.length;
+  }
+  async shareSnapshot(input) {
+    return this.db.transaction(async (tx) => {
+      const prior = await tx.select({ snapshotFactId: shares.snapshotFactId }).from(shares).where(
+        and(
+          eq(shares.toNamespaceId, input.share.toNamespaceId),
+          eq(shares.sourceFactId, input.share.sourceFactId),
+          eq(shares.mode, "snapshot")
+        )
+      ).limit(1);
+      const priorId = prior[0]?.snapshotFactId;
+      if (priorId) return { snapshotFactId: priorId };
+      const copy = await tx.select({ id: facts.id }).from(facts).where(
+        and(
+          eq(facts.namespaceId, input.snapshotFact.namespaceId),
+          eq(facts.contentHash, input.snapshotFact.contentHash)
+        )
+      ).limit(1);
+      const snapshotFactId = copy[0]?.id ?? input.snapshotFact.id;
+      if (!copy[0]) {
+        await tx.insert(facts).values({
+          id: input.snapshotFact.id,
+          namespaceId: input.snapshotFact.namespaceId,
+          subject: input.snapshotFact.subject,
+          predicate: input.snapshotFact.predicate,
+          object: input.snapshotFact.object,
+          content: input.snapshotFact.content,
+          contentHash: input.snapshotFact.contentHash,
+          sourceInteractionId: input.snapshotFact.sourceInteractionId ?? null,
+          createdByAgent: input.snapshotFact.createdByAgent ?? null
+        });
+        await tx.insert(embeddings).values({
+          id: input.embedding.id,
+          namespaceId: input.embedding.namespaceId,
+          ownerType: input.embedding.ownerType,
+          ownerId: input.embedding.ownerId,
+          vector: zeroVectorLiteral(),
+          embeddingModel: input.embedding.embeddingModel,
+          status: "pending"
+        });
+      }
+      await tx.insert(shares).values({
+        id: input.share.id,
+        fromNamespaceId: input.share.fromNamespaceId,
+        toNamespaceId: input.share.toNamespaceId,
+        sourceFactId: input.share.sourceFactId,
+        snapshotFactId,
+        mode: "snapshot",
+        createdByAgent: input.share.createdByAgent ?? null
+      }).onConflictDoUpdate({
+        target: [shares.toNamespaceId, shares.sourceFactId, shares.mode],
+        set: { snapshotFactId }
+      });
+      return { snapshotFactId };
+    });
+  }
+  async forgetInteraction(namespaceId, id, audit) {
+    return this.db.transaction(async (tx) => {
+      const existing = await tx.select({ id: interactions.id }).from(interactions).where(and(eq(interactions.namespaceId, namespaceId), eq(interactions.id, id))).for("update");
+      if (existing.length === 0) return { found: false, sourceDeletedFactIds: [] };
+      const marked = await tx.update(facts).set({ sourceDeleted: true }).where(and(eq(facts.namespaceId, namespaceId), eq(facts.sourceInteractionId, id))).returning({ id: facts.id });
+      await tx.delete(interactions).where(and(eq(interactions.namespaceId, namespaceId), eq(interactions.id, id)));
+      await tx.delete(embeddings).where(
+        and(
+          eq(embeddings.namespaceId, namespaceId),
+          eq(embeddings.ownerType, "interaction"),
+          eq(embeddings.ownerId, id)
+        )
+      );
+      await tx.insert(auditLog).values(toAuditRow(audit));
+      return { found: true, sourceDeletedFactIds: marked.map((row) => row.id) };
+    });
+  }
+  async forgetFact(namespaceId, id, audit) {
+    return this.db.transaction(async (tx) => {
+      const deleted = await tx.delete(facts).where(and(eq(facts.namespaceId, namespaceId), eq(facts.id, id))).returning({ id: facts.id });
+      if (deleted.length === 0) return { found: false };
+      await tx.delete(embeddings).where(
+        and(
+          eq(embeddings.namespaceId, namespaceId),
+          eq(embeddings.ownerType, "fact"),
+          eq(embeddings.ownerId, id)
+        )
+      );
+      await tx.update(shares).set({ tombstoned: true }).where(
+        and(
+          eq(shares.fromNamespaceId, namespaceId),
+          eq(shares.sourceFactId, id),
+          eq(shares.mode, "reference")
+        )
+      );
+      await tx.insert(auditLog).values(toAuditRow(audit));
+      return { found: true };
+    });
+  }
+  async forgetSummary(namespaceId, id, audit) {
+    return this.db.transaction(async (tx) => {
+      const deleted = await tx.delete(sessionSummaries).where(and(eq(sessionSummaries.namespaceId, namespaceId), eq(sessionSummaries.id, id))).returning({ id: sessionSummaries.id });
+      if (deleted.length === 0) return { found: false };
+      await tx.delete(embeddings).where(
+        and(
+          eq(embeddings.namespaceId, namespaceId),
+          eq(embeddings.ownerType, "summary"),
+          eq(embeddings.ownerId, id)
+        )
+      );
+      await tx.insert(auditLog).values(toAuditRow(audit));
+      return { found: true };
+    });
+  }
+  async recordModelCall(entry) {
+    await this.db.insert(modelCalls).values({
+      id: entry.id,
+      namespaceId: entry.namespaceId ?? null,
+      model: entry.metadata.model,
+      type: entry.metadata.type,
+      latencyMs: entry.metadata.latencyMs,
+      tokens: entry.metadata.tokens ?? null,
+      status: entry.metadata.status,
+      error: entry.metadata.error ?? null,
+      metadata: {
+        retries: entry.metadata.retries,
+        fallbackTriggered: entry.metadata.fallbackTriggered,
+        coldStartWaitMs: entry.metadata.coldStartWaitMs
+      }
+    });
+  }
+  async recordAudit(entry) {
+    await this.db.insert(auditLog).values(toAuditRow(entry));
+  }
+  async getReadyEmbeddings(namespaceId, limit, space) {
+    const rows = await this.client.sql`
+      select e.id, e.owner_type, e.owner_id, e.embedding_model, e.embedding_space,
+        e.vector::text as vector
+      from embeddings e
+      where e.status = 'ready'
+        and (${space ?? null}::text is null or e.embedding_space = ${space ?? null})
+        and (
+          e.namespace_id = ${namespaceId}
+          or (
+            e.owner_type = 'fact'
+            and exists (
+              select 1 from shares s
+              where s.to_namespace_id = ${namespaceId}
+                and s.from_namespace_id = e.namespace_id
+                and s.source_fact_id = e.owner_id
+                and s.mode = 'reference'
+                and not s.tombstoned
+            )
+          )
+        )
+      order by e.updated_at desc
+      limit ${limit}
+    `;
+    return rows.map((row) => ({
+      embeddingId: row.id,
+      ownerType: row.owner_type,
+      ownerId: row.owner_id,
+      embeddingModel: row.embedding_model,
+      embeddingSpace: row.embedding_space,
+      vector: parseVectorLiteral(row.vector)
+    }));
+  }
+  async requeueEmbeddingsOutsideSpace(namespaceId, space) {
+    const rows = await this.db.update(embeddings).set({
+      status: "pending",
+      vector: zeroVectorLiteral(),
+      attempts: 0,
+      lastError: null,
+      leaseUntil: null,
+      leaseToken: null,
+      updatedAt: sql2`now()`
+    }).where(
+      and(
+        eq(embeddings.namespaceId, namespaceId),
+        inArray(embeddings.status, ["ready", "failed"]),
+        sql2`${embeddings.embeddingSpace} is distinct from ${space}`
+      )
+    ).returning({ id: embeddings.id });
+    return rows.length;
+  }
+  async searchSimilarEmbeddings(input) {
+    if (!validSearchVector(input.vector))
+      return { method: "exact_pgvector", candidates: [], compatibleReady: 0 };
+    const rows = await this.db.execute(sql2`
+      with compatible as materialized (
+        select id, owner_type, owner_id, embedding_model, embedding_space, vector
+        from embeddings
+        where status = 'ready'
+          and (
+            namespace_id = ${input.namespaceId}
+            or (
+              owner_type = 'fact'
+              and ${liveReference(input.namespaceId, sql2`embeddings.namespace_id`, sql2`embeddings.owner_id`)}
+            )
+          )
+          and embedding_space = ${input.embeddingSpace}
+          and embedding_model = ${input.embeddingModel}
+          and vector_norm(vector) > 0
+          and not exists (
+            select 1 from facts f
+            where owner_type = 'fact' and f.namespace_id = embeddings.namespace_id
+              and f.id = embeddings.owner_id
+              and (f.source_deleted or f.superseded_by is not null)
+          )
+      )
+      select id, owner_type, owner_id, embedding_model, embedding_space,
+        1 - (vector <=> ${JSON.stringify(input.vector)}::vector) as score,
+        count(*) over () as total
+      from compatible
+      order by vector <=> ${JSON.stringify(input.vector)}::vector, id collate "C"
+      limit ${candidateLimit(input.limit)}
+    `);
+    return {
+      method: "exact_pgvector",
+      compatibleReady: Number(rows[0]?.total ?? 0),
+      candidates: rows.map((row) => ({
+        embeddingId: row.id,
+        ownerType: row.owner_type,
+        ownerId: row.owner_id,
+        embeddingModel: row.embedding_model,
+        embeddingSpace: row.embedding_space,
+        score: Number(row.score)
+      }))
+    };
+  }
+  async searchFactsLexically(namespaceId, query, limit) {
+    const terms = lexicalTerms(query);
+    if (!terms.length) return { candidates: [], matchedFacts: 0 };
+    const rows = await this.db.execute(sql2`
+      with scored as materialized (
+        select id, content, subject, predicate, object, proposition_key, confidence,
+          created_by_agent, created_at,
+          (select coalesce(sum(
+            (case when strpos(' ' || regexp_replace(lower(subject || ' ' || object), '[^[:alnum:]_]+', ' ', 'g') || ' ', ' ' || term || ' ') > 0 then 2 else 0 end) +
+            (case when strpos(' ' || regexp_replace(lower(content), '[^[:alnum:]_]+', ' ', 'g') || ' ', ' ' || term || ' ') > 0 then 1 else 0 end)
+          ), 0)::float / ${3 * terms.length} from
+            jsonb_array_elements_text(${JSON.stringify(terms)}::jsonb) term
+          ) as score
+        from facts
+        where not source_deleted and superseded_by is null
+          and (
+            namespace_id = ${namespaceId}
+            or ${liveReference(namespaceId, sql2`facts.namespace_id`, sql2`facts.id`)}
+          )
+      )
+      select *, count(*) over () as total from scored where score > 0
+      order by score desc, created_at desc, id collate "C"
+      limit ${candidateLimit(limit)}
+    `);
+    return {
+      matchedFacts: Number(rows[0]?.total ?? 0),
+      candidates: rows.map((row) => ({
+        id: row.id,
+        content: row.content,
+        subject: row.subject,
+        predicate: row.predicate,
+        object: row.object,
+        propositionKey: row.proposition_key,
+        confidence: Number(row.confidence),
+        sourceDeleted: false,
+        supersededBy: null,
+        createdByAgent: row.created_by_agent,
+        createdAt: new Date(row.created_at),
+        score: Number(row.score)
+      }))
+    };
+  }
+  async getRecentInteractions(namespaceId, sessionId, limit) {
+    const rows = await this.db.select({
+      id: interactions.id,
+      sessionId: interactions.sessionId,
+      content: interactions.content,
+      tokenCount: interactions.tokenCount,
+      createdAt: interactions.createdAt
+    }).from(interactions).where(and(eq(interactions.namespaceId, namespaceId), eq(interactions.sessionId, sessionId))).orderBy(desc(interactions.createdAt)).limit(limit);
+    return rows.map((row) => ({ ...row, createdAt: row.createdAt }));
+  }
+  async getRecentFacts(namespaceId, limit) {
+    const rows = await this.db.select(recentFactColumns).from(facts).where(
+      and(
+        eq(facts.namespaceId, namespaceId),
+        eq(facts.sourceDeleted, false),
+        isNull(facts.supersededBy)
+      )
+    ).orderBy(desc(facts.createdAt)).limit(limit);
+    return rows.map((row) => ({ ...row, confidence: Number(row.confidence ?? 1) }));
+  }
+  async getLatestSummary(namespaceId, sessionId) {
+    const rows = await this.db.select({
+      id: sessionSummaries.id,
+      sessionId: sessionSummaries.sessionId,
+      content: sessionSummaries.content,
+      tokenCount: sessionSummaries.tokenCount,
+      createdAt: sessionSummaries.createdAt
+    }).from(sessionSummaries).where(
+      and(
+        eq(sessionSummaries.namespaceId, namespaceId),
+        eq(sessionSummaries.sessionId, sessionId)
+      )
+    ).orderBy(desc(sessionSummaries.version)).limit(1);
+    return rows[0] ?? null;
+  }
+  async getInteractionsByIds(namespaceId, ids) {
+    if (ids.length === 0) return [];
+    const rows = await this.db.select({
+      id: interactions.id,
+      sessionId: interactions.sessionId,
+      content: interactions.content,
+      tokenCount: interactions.tokenCount,
+      createdAt: interactions.createdAt
+    }).from(interactions).where(and(eq(interactions.namespaceId, namespaceId), inArray(interactions.id, ids)));
+    return rows;
+  }
+  async getFactsByIds(namespaceId, ids) {
+    if (ids.length === 0) return [];
+    const rows = await this.db.select(recentFactColumns).from(facts).where(
+      and(
+        inArray(facts.id, ids),
+        isNull(facts.supersededBy),
+        or(
+          eq(facts.namespaceId, namespaceId),
+          liveReference(namespaceId, sql2`${facts.namespaceId}`, sql2`${facts.id}`)
+        )
+      )
+    );
+    return rows.map((row) => ({ ...row, confidence: Number(row.confidence ?? 1) }));
+  }
+  async getSummariesByIds(namespaceId, ids) {
+    if (ids.length === 0) return [];
+    const rows = await this.db.select({
+      id: sessionSummaries.id,
+      sessionId: sessionSummaries.sessionId,
+      content: sessionSummaries.content,
+      tokenCount: sessionSummaries.tokenCount,
+      createdAt: sessionSummaries.createdAt
+    }).from(sessionSummaries).where(and(eq(sessionSummaries.namespaceId, namespaceId), inArray(sessionSummaries.id, ids)));
+    return rows;
+  }
+  async getFactById(namespaceId, id) {
+    const rows = await this.db.select({
+      id: facts.id,
+      subject: facts.subject,
+      predicate: facts.predicate,
+      object: facts.object,
+      content: facts.content,
+      confidence: facts.confidence,
+      sourceInteractionId: facts.sourceInteractionId,
+      sourceDeleted: facts.sourceDeleted,
+      supersededBy: facts.supersededBy,
+      createdByAgent: facts.createdByAgent,
+      createdAt: facts.createdAt
+    }).from(facts).where(and(eq(facts.namespaceId, namespaceId), eq(facts.id, id))).limit(1);
+    const row = rows[0];
+    if (!row) return null;
+    return { ...row, confidence: Number(row.confidence ?? 1) };
+  }
+  async countEmbeddingStatuses(namespaceId) {
+    const rows = await this.client.sql`
+      select status::text as status, count(*)::text as count
+      from embeddings
+      where namespace_id = ${namespaceId}
+      group by status
+    `;
+    let pending = 0;
+    let processing = 0;
+    let failed = 0;
+    let ready = 0;
+    for (const row of rows) {
+      const value = Number(row.count);
+      if (row.status === "pending") pending = value;
+      else if (row.status === "processing") processing = value;
+      else if (row.status === "failed") failed = value;
+      else if (row.status === "ready") ready = value;
+    }
+    return { pending, processing, failed, ready };
+  }
+  async listFacts(input) {
+    const where = [
+      eq(facts.namespaceId, input.namespaceId),
+      eq(facts.sourceDeleted, false),
+      isNull(facts.supersededBy),
+      input.subject ? eq(facts.subject, input.subject) : void 0,
+      input.cursor ? or(
+        lt(facts.createdAt, input.cursor.createdAt),
+        and(eq(facts.createdAt, input.cursor.createdAt), lt(facts.id, input.cursor.id))
+      ) : void 0
+    ].filter((clause) => Boolean(clause));
+    const rows = await this.db.select({
+      id: facts.id,
+      subject: facts.subject,
+      predicate: facts.predicate,
+      object: facts.object,
+      content: facts.content,
+      confidence: facts.confidence,
+      sourceInteractionId: facts.sourceInteractionId,
+      sourceDeleted: facts.sourceDeleted,
+      supersededBy: facts.supersededBy,
+      createdByAgent: facts.createdByAgent,
+      createdAt: facts.createdAt
+    }).from(facts).where(and(...where)).orderBy(desc(facts.createdAt), desc(facts.id)).limit(input.limit);
+    return rows.map((row) => ({ ...row, confidence: Number(row.confidence ?? 1) }));
+  }
+  async listSummaries(input) {
+    return this.db.select({
+      id: sessionSummaries.id,
+      sessionId: sessionSummaries.sessionId,
+      content: sessionSummaries.content,
+      version: sessionSummaries.version,
+      tokenCount: sessionSummaries.tokenCount,
+      createdByAgent: sessionSummaries.createdByAgent,
+      createdAt: sessionSummaries.createdAt
+    }).from(sessionSummaries).where(eq(sessionSummaries.namespaceId, input.namespaceId)).orderBy(desc(sessionSummaries.createdAt)).limit(input.limit);
+  }
+  async listNamespaces() {
+    const rows = await this.client.sql`
+      select
+        n.name,
+        count(f.id)::text as fact_count,
+        greatest(
+          max(f.created_at),
+          max(i.created_at),
+          max(s.created_at),
+          n.updated_at
+        ) as last_activity
+      from namespaces n
+      left join facts f on f.namespace_id = n.id and f.source_deleted = false
+      left join interactions i on i.namespace_id = n.id
+      left join session_summaries s on s.namespace_id = n.id
+      group by n.id, n.name, n.updated_at
+      order by last_activity desc nulls last, n.name asc
+    `;
+    return rows.map((row) => ({
+      name: row.name,
+      factCount: Number(row.fact_count),
+      lastActivity: row.last_activity
+    }));
+  }
+  async getAgentWriteBreakdown(namespaceId) {
+    const rows = namespaceId ? await this.client.sql`
+          select agent_id, sum(writes)::text as writes
+          from (
+            select created_by_agent as agent_id, count(*) as writes from interactions where namespace_id = ${namespaceId} group by created_by_agent
+            union all
+            select created_by_agent as agent_id, count(*) as writes from facts where namespace_id = ${namespaceId} group by created_by_agent
+            union all
+            select created_by_agent as agent_id, count(*) as writes from session_summaries where namespace_id = ${namespaceId} group by created_by_agent
+          ) t
+          group by agent_id
+          order by writes desc
+        ` : await this.client.sql`
+          select agent_id, sum(writes)::text as writes
+          from (
+            select created_by_agent as agent_id, count(*) as writes from interactions group by created_by_agent
+            union all
+            select created_by_agent as agent_id, count(*) as writes from facts group by created_by_agent
+            union all
+            select created_by_agent as agent_id, count(*) as writes from session_summaries group by created_by_agent
+          ) t
+          group by agent_id
+          order by writes desc
+        `;
+    return rows.map((row) => ({ agentId: row.agent_id, writes: Number(row.writes) }));
+  }
+  async getStats(namespaceId) {
+    const namespaceRows = await this.client.sql`select count(*)::text as count from namespaces`;
+    const interactionRows = namespaceId ? await this.client.sql`select count(*)::text as count from interactions where namespace_id = ${namespaceId}` : await this.client.sql`select count(*)::text as count from interactions`;
+    const factRows = namespaceId ? await this.client.sql`select count(*)::text as count from facts where namespace_id = ${namespaceId}` : await this.client.sql`select count(*)::text as count from facts`;
+    const summaryRows = namespaceId ? await this.client.sql`select count(*)::text as count from session_summaries where namespace_id = ${namespaceId}` : await this.client.sql`select count(*)::text as count from session_summaries`;
+    const embeddingRows = namespaceId ? await this.client.sql`
+          select status::text as status, count(*)::text as count from embeddings where namespace_id = ${namespaceId} group by status
+        ` : await this.client.sql`
+          select status::text as status, count(*)::text as count from embeddings group by status
+        `;
+    const callRows = namespaceId ? await this.client.sql`
+          select
+            count(*) filter (where created_at >= now() - interval '60 seconds')::text as last_60s,
+            count(*) filter (where created_at >= now() - interval '1 hour')::text as last_hour,
+            count(*) filter (where created_at >= now() - interval '24 hours')::text as last_24h,
+            count(*) filter (where status = 'gated' and created_at >= now() - interval '24 hours')::text as gated_failures
+          from model_calls
+          where namespace_id = ${namespaceId}
+        ` : await this.client.sql`
+          select
+            count(*) filter (where created_at >= now() - interval '60 seconds')::text as last_60s,
+            count(*) filter (where created_at >= now() - interval '1 hour')::text as last_hour,
+            count(*) filter (where created_at >= now() - interval '24 hours')::text as last_24h,
+            count(*) filter (where status = 'gated' and created_at >= now() - interval '24 hours')::text as gated_failures
+          from model_calls
+        `;
+    const embeddingsCount = { pending: 0, processing: 0, failed: 0, ready: 0 };
+    for (const row of embeddingRows) {
+      if (row.status === "pending") embeddingsCount.pending = Number(row.count);
+      if (row.status === "processing") embeddingsCount.processing = Number(row.count);
+      if (row.status === "failed") embeddingsCount.failed = Number(row.count);
+      if (row.status === "ready") embeddingsCount.ready = Number(row.count);
+    }
+    const calls = callRows[0] ?? {
+      last_60s: "0",
+      last_hour: "0",
+      last_24h: "0",
+      gated_failures: "0"
+    };
+    return {
+      namespaces: Number(namespaceRows[0]?.count ?? 0),
+      interactions: Number(interactionRows[0]?.count ?? 0),
+      facts: Number(factRows[0]?.count ?? 0),
+      summaries: Number(summaryRows[0]?.count ?? 0),
+      embeddings: embeddingsCount,
+      modelCalls: {
+        last60s: Number(calls.last_60s),
+        lastHour: Number(calls.last_hour),
+        last24h: Number(calls.last_24h),
+        gatedFailures: Number(calls.gated_failures)
+      }
+    };
+  }
+  async pruneBefore(cutoff) {
+    return this.db.transaction(async (tx) => {
+      const deletedInteractions = await tx.delete(interactions).where(lt(interactions.createdAt, cutoff)).returning({ id: interactions.id });
+      if (deletedInteractions.length > 0) {
+        await tx.delete(embeddings).where(
+          and(
+            eq(embeddings.ownerType, "interaction"),
+            inArray(
+              embeddings.ownerId,
+              deletedInteractions.map((row) => row.id)
+            )
+          )
+        );
+      }
+      const deletedFacts = await tx.delete(facts).where(lt(facts.createdAt, cutoff)).returning({ id: facts.id });
+      if (deletedFacts.length > 0) {
+        await tx.delete(embeddings).where(
+          and(
+            eq(embeddings.ownerType, "fact"),
+            inArray(
+              embeddings.ownerId,
+              deletedFacts.map((row) => row.id)
+            )
+          )
+        );
+        await tx.update(shares).set({ tombstoned: true }).where(
+          and(
+            eq(shares.mode, "reference"),
+            inArray(
+              shares.sourceFactId,
+              deletedFacts.map((row) => row.id)
+            )
+          )
+        );
+      }
+      const deletedSummaries = await tx.delete(sessionSummaries).where(lt(sessionSummaries.createdAt, cutoff)).returning({ id: sessionSummaries.id });
+      if (deletedSummaries.length > 0) {
+        await tx.delete(embeddings).where(
+          and(
+            eq(embeddings.ownerType, "summary"),
+            inArray(
+              embeddings.ownerId,
+              deletedSummaries.map((row) => row.id)
+            )
+          )
+        );
+      }
+      return {
+        interactions: deletedInteractions.length,
+        facts: deletedFacts.length,
+        summaries: deletedSummaries.length
+      };
+    });
+  }
+  async getVectorIndexHealth(namespaceId) {
+    const countRows = namespaceId ? await this.client.sql`select count(*)::text as count from embeddings where namespace_id = ${namespaceId}` : await this.client.sql`select count(*)::text as count from embeddings`;
+    const indexRows = await this.client.sql`
+      select indexname, indexdef from pg_indexes
+      where schemaname = current_schema()
+        and tablename = 'embeddings'
+        and indexname = 'embeddings_vector_hnsw_idx'
+      limit 1
+    `;
+    const vectorCount = Number(countRows[0]?.count ?? 0);
+    const index2 = indexRows[0];
+    return {
+      vectorCount,
+      indexName: index2?.indexname ?? null,
+      indexDefinition: index2?.indexdef ?? null,
+      needsTuning: vectorCount >= 1e5
+    };
+  }
+};
+function createPostgresRepository(client) {
+  return new PostgresMemoryRepository(client);
+}
+function toAuditRow(entry) {
+  return {
+    id: entry.id,
+    namespaceId: entry.namespaceId,
+    action: entry.action,
+    entityType: entry.entityType,
+    entityId: entry.entityId ?? null,
+    createdByAgent: entry.createdByAgent ?? null,
+    metadata: entry.metadata ?? {}
+  };
+}
+async function upsertPendingEmbedding(tx, embedding, reset) {
+  const insert = tx.insert(embeddings).values({
+    id: embedding.id,
+    namespaceId: embedding.namespaceId,
+    ownerType: embedding.ownerType,
+    ownerId: embedding.ownerId,
+    vector: zeroVectorLiteral(),
+    embeddingModel: embedding.embeddingModel,
+    status: "pending"
+  });
+  const target = [embeddings.ownerType, embeddings.ownerId];
+  if (!reset) {
+    await insert.onConflictDoNothing({ target });
+    return;
+  }
+  await insert.onConflictDoUpdate({
+    target,
+    set: {
+      vector: zeroVectorLiteral(),
+      embeddingModel: embedding.embeddingModel,
+      status: "pending",
+      attempts: 0,
+      lastError: null,
+      leaseUntil: null,
+      leaseToken: null,
+      updatedAt: sql2`now()`
+    }
+  });
+}
+function zeroVectorLiteral() {
+  return `[${Array.from({ length: 384 }, () => 0).join(",")}]`;
+}
+function parseVectorLiteral(literal) {
+  const trimmed = literal.startsWith("[") ? literal.slice(1, -1) : literal;
+  if (!trimmed) return [];
+  return trimmed.split(",").map((value) => Number(value));
+}
+function advisoryLockKeys(namespaceId, sessionId) {
+  const digest = createHash("sha256").update(`${namespaceId}${sessionId}`).digest();
+  const k1 = digest.readInt32BE(0);
+  const k2 = digest.readInt32BE(4);
+  return [k1, k2];
+}
+var recentFactColumns = {
+  id: facts.id,
+  content: facts.content,
+  subject: facts.subject,
+  predicate: facts.predicate,
+  object: facts.object,
+  propositionKey: facts.propositionKey,
+  confidence: facts.confidence,
+  sourceDeleted: facts.sourceDeleted,
+  supersededBy: facts.supersededBy,
+  createdByAgent: facts.createdByAgent,
+  createdAt: facts.createdAt
+};
+function liveReference(namespaceId, ownerNamespace, factId) {
+  return sql2`exists (
+    select 1 from shares s
+    where s.to_namespace_id = ${namespaceId}
+      and s.from_namespace_id = ${ownerNamespace}
+      and s.source_fact_id = ${factId}
+      and s.mode = 'reference'
+      and not s.tombstoned
+  )`;
+}
+
+// src/core/codebuddy.ts
+import pTimeout2 from "p-timeout";
+
+// 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/planner/default-policy.ts
+var DefaultPolicy = class {
+  recencyFloorSize;
+  embeddingCandidateLimit;
+  minVectorScore;
+  constructor(options = {}) {
+    this.recencyFloorSize = options.recencyFloorSize ?? 3;
+    this.embeddingCandidateLimit = candidateLimit(options.embeddingCandidateLimit ?? 256);
+    this.minVectorScore = options.minVectorScore ?? 0.1;
+  }
+  async plan(input) {
+    const repo = input.repository;
+    const counts = await repo.countEmbeddingStatuses(input.namespaceId);
+    const query = input.queryEmbedding;
+    const space = query ? embeddingSpaceKey(query.space) : null;
+    let fallbackReason;
+    if (!query) fallbackReason = "query_embedding_unavailable";
+    else if (!validSearchVector(query.vector) || !validEmbeddingVector(query.vector, query.space.dimensions))
+      fallbackReason = "invalid_query_vector";
+    const recencyInteractions = await repo.getRecentInteractions(
+      input.namespaceId,
+      input.sessionId,
+      this.recencyFloorSize
+    );
+    const coverage = {
+      scope: "full_namespace",
+      method: "lexical",
+      compatibleReady: 0,
+      candidateLimit: this.embeddingCandidateLimit,
+      vectorCandidates: 0,
+      lexicalCandidates: 0,
+      lexicalMatchedFacts: 0,
+      hydratedCandidates: 0,
+      spaceFilter: space
+    };
+    let candidates = [];
+    let fallback = "none";
+    if (!fallbackReason && query && space) {
+      const search = await repo.searchSimilarEmbeddings({
+        namespaceId: input.namespaceId,
+        vector: query.vector,
+        embeddingSpace: space,
+        embeddingModel: query.space.model,
+        limit: this.embeddingCandidateLimit
+      });
+      coverage.compatibleReady = search.compatibleReady;
+      coverage.vectorCandidates = search.candidates.length;
+      coverage.method = search.method;
+      const scored = search.candidates.map((row) => ({ row, score: row.score }));
+      const ownerIdsByType = groupOwnerIdsByType(scored);
+      const [factRows, interactionRows, summaryRows] = await Promise.all([
+        repo.getFactsByIds(input.namespaceId, ownerIdsByType.fact),
+        repo.getInteractionsByIds(input.namespaceId, ownerIdsByType.interaction),
+        repo.getSummariesByIds(input.namespaceId, ownerIdsByType.summary)
+      ]);
+      candidates = this.hydrateScored(scored, factRows, interactionRows, summaryRows);
+      coverage.hydratedCandidates = candidates.length;
+      if (search.compatibleReady === 0)
+        fallbackReason = counts.ready === 0 ? "no_ready_embeddings" : "no_compatible_embeddings";
+      else if (candidates.length === 0) fallbackReason = "no_hydratable_candidates";
+    }
+    const useFallback = fallbackReason !== void 0;
+    const lexical = await repo.searchFactsLexically(
+      input.namespaceId,
+      input.query,
+      useFallback ? this.embeddingCandidateLimit : Math.min(this.embeddingCandidateLimit, 32)
+    );
+    coverage.lexicalCandidates = lexical.candidates.length;
+    coverage.lexicalMatchedFacts = lexical.matchedFacts;
+    if (useFallback) {
+      const [summary, fallbackInteractions] = await Promise.all([
+        repo.getLatestSummary(input.namespaceId, input.sessionId),
+        repo.getRecentInteractions(
+          input.namespaceId,
+          input.sessionId,
+          Math.max(this.recencyFloorSize, 10)
+        )
+      ]);
+      candidates = this.buildFallbackCandidates(fallbackInteractions, summary);
+      if (summary && fallbackInteractions.length > 0) fallback = "recency_summary";
+      else if (summary) fallback = "summary";
+      else fallback = "recency";
+    }
+    const byKey = new Map(candidates.map((candidate) => [candidate.key, candidate]));
+    for (const fact of lexical.candidates) {
+      if (!isEligibleMemory(fact)) continue;
+      const candidate = factCandidate(fact, useFallback ? fact.score : 0.35 * fact.score);
+      const existing = byKey.get(candidate.key);
+      if (existing) existing.score = Math.max(existing.score, candidate.score);
+      else byKey.set(candidate.key, candidate);
+    }
+    candidates = [...byKey.values()];
+    candidates = this.applyRecencyFloor(candidates, recencyInteractions);
+    candidates = this.applyConflictMode(candidates, input.conflictMode);
+    candidates.sort((a, b) => {
+      if (a.isRecencyFloor !== b.isRecencyFloor) return a.isRecencyFloor ? -1 : 1;
+      return b.score - a.score || b.createdAt - a.createdAt || a.key.localeCompare(b.key);
+    });
+    const skipReasons = {};
+    const included = [];
+    let system = buildSystemPrompt(input.namespace, fallback, useFallback);
+    let tokensUsed = countTokens(system);
+    let itemsSkipped = 0;
+    for (const candidate of candidates) {
+      if (tokensUsed + candidate.tokens > input.budget) {
+        bump(skipReasons, "budget_exhausted");
+        itemsSkipped += 1;
+        continue;
+      }
+      if (!candidate.isRecencyFloor && candidate.score < this.minVectorScore && !useFallback) {
+        bump(skipReasons, "low_score");
+        itemsSkipped += 1;
+        continue;
+      }
+      included.push(candidate);
+      tokensUsed += candidate.tokens;
+    }
+    const unresolvedKeys = [
+      ...new Set(
+        included.flatMap(
+          (c) => c.fact?.conflict?.unresolved ? [c.fact.propositionKey ?? ""] : []
+        )
+      )
+    ].sort();
+    if (unresolvedKeys.length > 0) {
+      const noted = `${system} Unresolved fact conflicts (compare fact provenance): ${unresolvedKeys.join(", ")}.`;
+      const withNote = tokensUsed - countTokens(system) + countTokens(noted);
+      if (withNote <= input.budget) {
+        system = noted;
+        tokensUsed = withNote;
+      }
+    }
+    const messages = included.map((candidate) => ({
+      role: candidate.role,
+      content: candidate.content,
+      ...candidate.fact ? { fact: candidate.fact } : {}
+    }));
+    const stats = {
+      tokensUsed,
+      itemsIncluded: included.length,
+      itemsSkipped,
+      budgetHeadroom: Math.max(0, input.budget - tokensUsed),
+      fallback,
+      skipReasons,
+      embeddingCoverage: counts,
+      candidateCoverage: coverage,
+      ...fallbackReason ? { fallbackReason } : {},
+      explain: [
+        `Candidate search covers the full namespace; limit ${this.embeddingCandidateLimit} applies after ranking.`,
+        `Embedding space filter: ${coverage.spaceFilter ?? "unavailable"}; ${coverage.compatibleReady} compatible ready vectors; ${coverage.vectorCandidates} vector candidates; ${coverage.hydratedCandidates} hydrated.`,
+        `Durable lexical facts: ${coverage.lexicalCandidates} candidates of ${coverage.lexicalMatchedFacts} matches.`,
+        ...useFallback ? [
+          `Fallback: ${fallbackReason}; ${coverage.lexicalCandidates} durable lexical candidates of ${coverage.lexicalMatchedFacts} matches.`
+        ] : []
+      ],
+      budgetClamped: false,
+      budgetStatus: tokensUsed > input.budget ? "overflow" : "within_budget",
+      ...tokensUsed > input.budget ? { budgetWarning: "Required memory system prompt exceeds budget." } : {}
+    };
+    return { system, messages, stats };
+  }
+  hydrateScored(scored, factRows, interactionRows, summaryRows) {
+    const factById = new Map(factRows.map((row) => [row.id, row]));
+    const interactionById = new Map(interactionRows.map((row) => [row.id, row]));
+    const summaryById = new Map(summaryRows.map((row) => [row.id, row]));
+    const out = [];
+    for (const { row, score } of scored) {
+      if (row.ownerType === "fact") {
+        const fact = factById.get(row.ownerId);
+        if (!fact || !isEligibleMemory(fact)) continue;
+        out.push(factCandidate(fact, score));
+      } else if (row.ownerType === "interaction") {
+        const interaction = interactionById.get(row.ownerId);
+        if (!interaction) continue;
+        out.push({
+          key: `interaction:${interaction.id}`,
+          role: "user",
+          content: interaction.content,
+          tokens: countTokens(interaction.content),
+          score,
+          source: "interaction",
+          ownerId: interaction.id,
+          createdAt: interaction.createdAt.getTime(),
+          confidence: 1,
+          isRecencyFloor: false
+        });
+      } else {
+        const summary = summaryById.get(row.ownerId);
+        if (!summary) continue;
+        out.push({
+          key: `summary:${summary.id}`,
+          role: "system",
+          content: summary.content,
+          tokens: countTokens(summary.content),
+          score,
+          source: "summary",
+          ownerId: summary.id,
+          createdAt: summary.createdAt.getTime(),
+          confidence: 1,
+          isRecencyFloor: false
+        });
+      }
+    }
+    return out;
+  }
+  applyRecencyFloor(candidates, floor) {
+    const byKey = /* @__PURE__ */ new Map();
+    for (const candidate of candidates) byKey.set(candidate.key, candidate);
+    for (const row of floor) {
+      const key = `interaction:${row.id}`;
+      const existing = byKey.get(key);
+      if (existing) {
+        existing.isRecencyFloor = true;
+        continue;
+      }
+      byKey.set(key, {
+        key,
+        role: "user",
+        content: row.content,
+        tokens: countTokens(row.content),
+        score: 1,
+        source: "interaction",
+        ownerId: row.id,
+        createdAt: row.createdAt.getTime(),
+        confidence: 1,
+        isRecencyFloor: true
+      });
+    }
+    return Array.from(byKey.values());
+  }
+  buildFallbackCandidates(interactions2, summary) {
+    const out = [];
+    if (summary) {
+      out.push({
+        key: `summary:${summary.id}`,
+        role: "system",
+        content: summary.content,
+        tokens: countTokens(summary.content),
+        score: 1,
+        source: "summary",
+        ownerId: summary.id,
+        createdAt: summary.createdAt.getTime(),
+        confidence: 1,
+        isRecencyFloor: true
+      });
+    }
+    for (const row of interactions2) {
+      out.push({
+        key: `interaction:${row.id}`,
+        role: "user",
+        content: row.content,
+        tokens: countTokens(row.content),
+        score: 1,
+        source: "interaction",
+        ownerId: row.id,
+        createdAt: row.createdAt.getTime(),
+        confidence: 1,
+        isRecencyFloor: true
+      });
+    }
+    return out;
+  }
+  /**
+   * Resolve rival assertions of the same explicit proposition key. Facts without
+   * a key are treated as multi-valued and never grouped, so identical or
+   * different surface text alone never merges or splits claims.
+   */
+  applyConflictMode(candidates, mode) {
+    const groups = /* @__PURE__ */ new Map();
+    for (const candidate of candidates) {
+      const key = candidate.fact?.propositionKey;
+      if (!key) continue;
+      groups.set(key, [...groups.get(key) ?? [], candidate]);
+    }
+    const dropped = /* @__PURE__ */ new Set();
+    for (const bucket of groups.values()) {
+      if (bucket.length < 2) continue;
+      bucket.sort((a, b) => compareRivals(a, b, mode));
+      const winner = bucket[0];
+      const contenders = bucket.filter(
+        (c) => mode === "all" || c.createdAt === winner.createdAt && c.confidence === winner.confidence
+      );
+      const objects = new Set(contenders.map((c) => c.fact?.object.trim().toLowerCase()));
+      const conflict = {
+        candidateIds: bucket.map((c) => c.ownerId).sort(),
+        unresolved: objects.size > 1
+      };
+      for (const candidate of bucket) {
+        if (mode !== "all" && candidate !== winner) dropped.add(candidate.key);
+        else if (candidate.fact) candidate.fact = { ...candidate.fact, conflict };
+      }
+    }
+    return candidates.filter((candidate) => !dropped.has(candidate.key));
+  }
+};
+function compareRivals(a, b, mode) {
+  const byTime = b.createdAt - a.createdAt;
+  const byConfidence = b.confidence - a.confidence;
+  const ordered = mode === "highest_confidence" ? byConfidence || byTime : byTime || byConfidence;
+  return ordered || a.ownerId.localeCompare(b.ownerId);
+}
+function groupOwnerIdsByType(scored) {
+  const out = { fact: [], interaction: [], summary: [] };
+  for (const { row } of scored) {
+    out[row.ownerType].push(row.ownerId);
+  }
+  return out;
+}
+function bump(map, key) {
+  map[key] = (map[key] ?? 0) + 1;
+}
+function buildSystemPrompt(namespace, fallback, isFallback) {
+  const base = `Memory context for namespace "${namespace}".`;
+  if (isFallback) {
+    return `${base} Fallback active (${fallback}); vector search unavailable or empty.`;
+  }
+  return base;
+}
+function factCandidate(fact, score) {
+  return {
+    key: `fact:${fact.id}`,
+    role: "system",
+    content: fact.content,
+    tokens: countTokens(fact.content),
+    score,
+    source: "fact",
+    ownerId: fact.id,
+    createdAt: fact.createdAt.getTime(),
+    confidence: fact.confidence,
+    isRecencyFloor: false,
+    fact: {
+      id: fact.id,
+      subject: fact.subject,
+      predicate: fact.predicate,
+      object: fact.object,
+      propositionKey: fact.propositionKey,
+      confidence: fact.confidence,
+      createdAt: fact.createdAt.toISOString(),
+      createdByAgent: fact.createdByAgent
+    }
+  };
+}
+
+// src/providers/huggingface.ts
+import { HfInference, setLogger } from "@huggingface/inference";
+
+// src/providers/resilience.ts
+import PQueue from "p-queue";
+import pRetry, { AbortError } from "p-retry";
+import pTimeout from "p-timeout";
+var DEFAULT_RESILIENCE_OPTIONS = {
+  retries: 5,
+  concurrency: 2,
+  rateLimitPerMinute: 10,
+  timeoutMs: 9e4,
+  warmCacheTtlMs: 5 * 6e4,
+  coldStartBufferMs: 2e3,
+  jitterMs: 250,
+  minRetryTimeoutMs: 1e3,
+  maxRetryTimeoutMs: 3e4
+};
+var GatedModelError = class extends Error {
+  model;
+  constructor(model) {
+    super(
+      `Model ${model} is gated. Accept the license at https://huggingface.co/${model} and retry.`
+    );
+    this.name = "GatedModelError";
+    this.model = model;
+  }
+};
+var UnauthorizedError = class extends Error {
+  constructor() {
+    super("Hugging Face rejected the API token (401). Set a valid HF token and retry.");
+    this.name = "UnauthorizedError";
+  }
+};
+var ModelUnavailableError = class extends Error {
+  model;
+  constructor(model, cause) {
+    super(`Model ${model} is unavailable.`);
+    this.name = "ModelUnavailableError";
+    this.model = model;
+    this.cause = cause;
+  }
+};
+var HuggingFaceResilience = class {
+  options;
+  queues = /* @__PURE__ */ new Map();
+  warmUntil = /* @__PURE__ */ new Map();
+  constructor(options = {}) {
+    this.options = {
+      ...DEFAULT_RESILIENCE_OPTIONS,
+      ...options
+    };
+  }
+  isWarm(model, now = Date.now()) {
+    return (this.warmUntil.get(model) ?? 0) > now;
+  }
+  markWarm(model, now = Date.now()) {
+    this.warmUntil.set(model, now + this.options.warmCacheTtlMs);
+  }
+  async execute(input) {
+    const models = [input.model, ...input.fallbackModels ?? []];
+    let lastError;
+    for (const [index2, model] of models.entries()) {
+      const fallbackTriggered = index2 > 0;
+      try {
+        return await this.executeForModel(model, input, fallbackTriggered);
+      } catch (error) {
+        lastError = error;
+        if (error instanceof GatedModelError || error instanceof UnauthorizedError) {
+          throw error;
+        }
+      }
+    }
+    throw lastError instanceof Error ? lastError : new Error("All provider models failed.");
+  }
+  async executeForModel(model, input, fallbackTriggered) {
+    const queue = this.getQueue(model);
+    const startedAt = Date.now();
+    let retries = 0;
+    let coldStartWaitMs = 0;
+    let status = fallbackTriggered ? "fallback" : "success";
+    try {
+      const result = await queue.add(
+        async () => pRetry(
+          async () => {
+            try {
+              return await pTimeout(input.call(model), {
+                milliseconds: this.options.timeoutMs
+              });
+            } catch (error) {
+              const classified = classifyHuggingFaceError(error, model);
+              if (classified.kind === "gated") {
+                status = "gated";
+                throw new AbortError(new GatedModelError(model));
+              }
+              if (classified.kind === "unauthorized") {
+                throw new AbortError(new UnauthorizedError());
+              }
+              if (classified.kind === "cold_start") {
+                const waitMs = this.calculateColdStartWaitMs(classified.estimatedTimeSeconds);
+                coldStartWaitMs += waitMs;
+                await (input.sleep ?? sleep)(waitMs);
+                throw error;
+              }
+              if (classified.kind === "rate_limited") {
+                status = "rate_limited";
+                if (classified.retryAfterMs) {
+                  await (input.sleep ?? sleep)(classified.retryAfterMs);
+                }
+                throw error;
+              }
+              if (classified.kind === "unavailable") {
+                throw new ModelUnavailableError(model, error);
+              }
+              if (classified.kind === "timeout") {
+                status = "timeout";
+              }
+              throw error;
+            }
+          },
+          {
+            retries: this.options.retries,
+            minTimeout: this.options.minRetryTimeoutMs,
+            maxTimeout: this.options.maxRetryTimeoutMs,
+            factor: 2,
+            randomize: true,
+            onFailedAttempt: (error) => {
+              retries = error.attemptNumber;
+            }
+          }
+        ),
+        { throwOnTimeout: true }
+      );
+      this.markWarm(model);
+      status = fallbackTriggered ? "fallback" : "success";
+      await input.onDiagnostic?.({
+        model,
+        type: input.type,
+        status,
+        latencyMs: Date.now() - startedAt,
+        retries,
+        fallbackTriggered,
+        coldStartWaitMs
+      });
+      return result;
+    } catch (error) {
+      const finalError = error instanceof AbortError && error.originalError ? error.originalError : error;
+      const classified = classifyHuggingFaceError(finalError, model);
+      const finalStatus = statusForClassifiedError(classified.kind, status);
+      await input.onDiagnostic?.({
+        model,
+        type: input.type,
+        status: finalStatus,
+        latencyMs: Date.now() - startedAt,
+        error: finalError instanceof Error ? finalError.message : String(finalError),
+        retries,
+        fallbackTriggered,
+        coldStartWaitMs
+      });
+      throw finalError;
+    }
+  }
+  getQueue(model) {
+    const existing = this.queues.get(model);
+    if (existing) {
+      return existing;
+    }
+    const queue = new PQueue({
+      concurrency: this.options.concurrency,
+      intervalCap: this.options.rateLimitPerMinute,
+      interval: 6e4
+    });
+    this.queues.set(model, queue);
+    return queue;
+  }
+  calculateColdStartWaitMs(estimatedTimeSeconds) {
+    return Math.ceil(
+      estimatedTimeSeconds * 1e3 + this.options.coldStartBufferMs + this.randomJitter()
+    );
+  }
+  randomJitter() {
+    return Math.floor(Math.random() * this.options.jitterMs);
+  }
+};
+function classifyHuggingFaceError(error, model) {
+  if (error instanceof GatedModelError) {
+    return { kind: "gated" };
+  }
+  if (error instanceof ModelUnavailableError) {
+    return { kind: "unavailable" };
+  }
+  if (error instanceof UnauthorizedError) {
+    return { kind: "unauthorized" };
+  }
+  if (error instanceof Error && error.name === "TimeoutError") {
+    return { kind: "timeout" };
+  }
+  const hfError = error;
+  const status = hfError.status ?? hfError.statusCode ?? hfError.response?.status ?? // @huggingface/inference 4.x errors carry the code here.
+  hfError.httpResponse?.status;
+  if (status === 401) {
+    return { kind: "unauthorized" };
+  }
+  if (status === 403) {
+    return { kind: "gated" };
+  }
+  if (status === 404) {
+    return { kind: "unavailable" };
+  }
+  if (status === 429) {
+    const retryAfterMs = readRetryAfterMs(hfError);
+    return retryAfterMs === void 0 ? { kind: "rate_limited" } : { kind: "rate_limited", retryAfterMs };
+  }
+  if (status === 503) {
+    const estimatedTimeSeconds = readEstimatedTimeSeconds(hfError);
+    if (estimatedTimeSeconds !== void 0) {
+      return { kind: "cold_start", estimatedTimeSeconds };
+    }
+  }
+  if (error instanceof Error && error.message.includes("timed out")) {
+    return { kind: "timeout" };
+  }
+  if (error instanceof Error && error.message.includes(model) && error.message.includes("gated")) {
+    return { kind: "gated" };
+  }
+  return { kind: "unknown" };
+}
+function statusForClassifiedError(kind, currentStatus) {
+  if (kind === "gated") {
+    return "gated";
+  }
+  if (kind === "rate_limited") {
+    return "rate_limited";
+  }
+  if (kind === "timeout") {
+    return "timeout";
+  }
+  if (currentStatus === "fallback") {
+    return "fallback";
+  }
+  return "failed";
+}
+function readEstimatedTimeSeconds(error) {
+  if (typeof error.estimated_time === "number") {
+    return error.estimated_time;
+  }
+  if (typeof error.estimatedTime === "number") {
+    return error.estimatedTime;
+  }
+  if (typeof error.cause === "object" && error.cause !== null && "estimated_time" in error.cause) {
+    const estimatedTime = error.cause.estimated_time;
+    return typeof estimatedTime === "number" ? estimatedTime : void 0;
+  }
+  return void 0;
+}
+function readRetryAfterMs(error) {
+  const retryAfter = error.response?.headers?.get?.("retry-after");
+  if (!retryAfter) {
+    return void 0;
+  }
+  const retryAfterSeconds = Number(retryAfter);
+  return Number.isFinite(retryAfterSeconds) ? retryAfterSeconds * 1e3 : void 0;
+}
+function sleep(ms) {
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
+}
+
+// src/providers/huggingface.ts
+var toStderr = (...args) => console.error(...args);
+setLogger({ debug: toStderr, info: toStderr, log: toStderr, warn: toStderr, error: toStderr });
+var HuggingFaceProvider = class {
+  client;
+  embeddingModels;
+  llmModels;
+  resilience;
+  onDiagnostic;
+  /** The primary model's space: `reindex` re-embeds rows from any other (incl. fallback) space. */
+  space;
+  constructor(options = {}) {
+    this.client = options.client ?? new HfInference(options.apiKey);
+    this.embeddingModels = options.embeddingModels ?? DEFAULT_EMBEDDING_MODELS;
+    this.llmModels = options.llmModels ?? DEFAULT_LLM_MODELS;
+    this.resilience = new HuggingFaceResilience({
+      ...DEFAULT_RESILIENCE_OPTIONS,
+      ...options.resilience
+    });
+    this.onDiagnostic = options.onDiagnostic;
+    assertCompatibleEmbeddingModels(this.embeddingModels);
+    const primary = this.embeddingModels[0];
+    if (primary) {
+      this.space = {
+        model: primary.id,
+        revision: primary.revision ?? "unversioned",
+        schema: primary.schema ?? "hf-feature-extraction-v1",
+        dimensions: primary.dimensions ?? EMBEDDING_DIMENSIONS
+      };
+    }
+  }
+  async embed(request) {
+    const primaryModel = request.model ?? this.embeddingModels[0]?.id;
+    if (!primaryModel) {
+      throw new Error("No embedding model configured.");
+    }
+    const fallbackModels = this.embeddingModels.map((model) => model.id).filter((model) => model !== primaryModel);
+    return this.resilience.execute({
+      model: primaryModel,
+      fallbackModels,
+      type: "embedding",
+      ...this.onDiagnostic ? { onDiagnostic: this.onDiagnostic } : {},
+      call: async (model) => {
+        const response = await this.client.featureExtraction({
+          model,
+          inputs: request.input
+        });
+        const definition = this.embeddingModels.find((entry) => entry.id === model);
+        const vectors = normalizeEmbeddingResponse(response);
+        const dimensions = vectors[0]?.length ?? 0;
+        const result = {
+          model,
+          revision: definition?.revision ?? "unversioned",
+          schema: definition?.schema ?? "hf-feature-extraction-v1",
+          dimensions,
+          vectors
+        };
+        validateEmbeddingResponse(
+          result,
+          typeof request.input === "string" ? 1 : request.input.length
+        );
+        if (dimensions !== (definition?.dimensions ?? EMBEDDING_DIMENSIONS)) {
+          throw new Error(
+            `Embedding model ${model} returned unexpected dimensions: ${dimensions}.`
+          );
+        }
+        return result;
+      }
+    });
+  }
+  async generateText(request) {
+    const primaryModel = request.model ?? this.llmModels[0]?.id;
+    if (!primaryModel) {
+      throw new Error("No LLM model configured.");
+    }
+    const fallbackModels = this.llmModels.map((model) => model.id).filter((model) => model !== primaryModel);
+    return this.resilience.execute({
+      model: primaryModel,
+      fallbackModels,
+      type: "llm",
+      ...this.onDiagnostic ? { onDiagnostic: this.onDiagnostic } : {},
+      call: async (model) => {
+        const response = await this.client.textGeneration({
+          model,
+          inputs: request.prompt
+        });
+        return {
+          model,
+          text: response.generated_text
+        };
+      }
+    });
+  }
+};
+function normalizeEmbeddingResponse(response) {
+  if (!Array.isArray(response)) {
+    throw new Error("Unexpected Hugging Face embedding response.");
+  }
+  if (response.every((value) => typeof value === "number")) {
+    return [response];
+  }
+  if (response.every(
+    (vector2) => Array.isArray(vector2) && vector2.every((value) => typeof value === "number")
+  )) {
+    return response;
+  }
+  throw new Error("Unexpected Hugging Face embedding vector shape.");
+}
+
+// src/tracing/langsmith.ts
+function isLangSmithTracingEnabled(env = process.env) {
+  return env.LANGCHAIN_TRACING_V2 === "true" || env.LANGSMITH_TRACING === "true";
+}
+function createTracer(env = process.env) {
+  const enabled = isLangSmithTracingEnabled(env);
+  if (!enabled) {
+    return {
+      enabled: false,
+      startSpan: () => noopSpan,
+      withSpan: async (_name, _input, fn) => fn()
+    };
+  }
+  return {
+    enabled: true,
+    startSpan(name, input) {
+      const started = Date.now();
+      log("span:start", { name, input });
+      return {
+        end(metadata) {
+          log("span:end", { name, durationMs: Date.now() - started, metadata });
+        },
+        fail(error, metadata) {
+          log("span:fail", {
+            name,
+            durationMs: Date.now() - started,
+            error: error instanceof Error ? error.message : String(error),
+            metadata
+          });
+        }
+      };
+    },
+    async withSpan(name, input, fn) {
+      const span = this.startSpan(name, input);
+      try {
+        const result = await fn();
+        span.end();
+        return result;
+      } catch (error) {
+        span.fail(error);
+        throw error;
+      }
+    }
+  };
+}
+var noopSpan = {
+  end: () => void 0,
+  fail: () => void 0
+};
+function log(event, payload) {
+  if (process.env.NODE_ENV === "test") return;
+  process.stderr.write(`${JSON.stringify({ at: "tracer", event, ...payload })}
+`);
+}
+
+// src/core/config.ts
+import { z } from "zod";
+var providerSchema = z.object({
+  type: z.enum(["local", "huggingface", "openrouter"]),
+  apiKey: z.string().min(1).optional(),
+  model: z.string().min(1).optional(),
+  relevanceFloor: z.number().min(-1).max(1).optional()
+});
+var codeBuddyConfigSchema = z.object({
+  postgresUrl: z.string().min(1, "postgresUrl is required"),
+  provider: providerSchema,
+  namespace: z.string().min(1, "namespace is required").max(128, "namespace must be 128 chars or fewer").regex(/^[a-zA-Z0-9_.:-]+$/, "namespace must match [a-zA-Z0-9_.:-]+"),
+  projectRoot: z.string().min(1).optional(),
+  tokenBudget: z.number().int().positive().max(1e6).optional(),
+  graphify: z.object({
+    enabled: z.boolean(),
+    graphPath: z.string().min(1).optional()
+  }).optional(),
+  worker: z.object({
+    pollIntervalMs: z.number().int().min(50).max(6e4).optional(),
+    batchSize: z.number().int().min(1).max(64).optional(),
+    maxAttempts: z.number().int().min(1).max(20).optional()
+  }).optional()
+});
+function validateConfig(config) {
+  return codeBuddyConfigSchema.parse(config);
+}
+
+// src/core/memory-file-store.ts
+import { mkdir, readdir, readFile, rm } from "fs/promises";
+import { dirname as dirname2, join, relative, resolve as resolve2, sep } from "path";
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+import { z as z2 } from "zod";
+var FACT_CATEGORIES = ["general", "incident"];
+var INCIDENT_SEVERITIES = ["low", "medium", "high", "critical"];
+var factFrontMatterSchema = z2.object({
+  schemaVersion: z2.literal(1),
+  id: z2.string().regex(/^fact_[a-z0-9]+$/),
+  namespace: z2.string().min(1),
+  type: z2.literal("fact"),
+  subject: z2.string(),
+  predicate: z2.string(),
+  object: z2.string(),
+  /** Explicit single-valued claim identity; facts sharing it are rival assertions. */
+  propositionKey: z2.string().min(1).nullable().default(null),
+  confidence: z2.number().min(0).max(1),
+  createdAt: z2.preprocess(
+    (value) => value instanceof Date ? value.toISOString() : value,
+    z2.string().datetime()
+  ),
+  createdByAgent: z2.string().nullable(),
+  sourceInteractionId: z2.string().nullable(),
+  sourceDeleted: z2.boolean(),
+  category: z2.enum(FACT_CATEGORIES).default("general"),
+  paths: z2.array(z2.string().min(1)).default([]),
+  severity: z2.enum(INCIDENT_SEVERITIES).nullable().default(null),
+  introducedBy: z2.string().nullable().default(null),
+  resolvedBy: z2.string().nullable().default(null),
+  fingerprint: z2.string().regex(/^[a-f0-9]{64}$/).nullable().default(null),
+  sourcePlanId: z2.string().nullable().default(null),
+  sourceSessionId: z2.string().nullable().default(null),
+  verification: z2.array(z2.string()).default([]),
+  supersededBy: z2.string().nullable().default(null),
+  /** Namespaces granted a live reference to this fact (durable form of reference shares). */
+  sharedWith: z2.array(z2.string().min(1)).default([])
+});
+var summaryFrontMatterSchema = z2.object({
+  schemaVersion: z2.literal(1),
+  id: z2.string().regex(/^sum_[a-z0-9]+$/),
+  namespace: z2.string().min(1),
+  type: z2.literal("summary"),
+  sessionId: z2.string().min(1),
+  version: z2.number().int().positive(),
+  tokenCount: z2.number().int().nonnegative(),
+  createdAt: z2.preprocess(
+    (value) => value instanceof Date ? value.toISOString() : value,
+    z2.string().datetime()
+  ),
+  createdByAgent: z2.string().nullable()
+});
+var MemoryFileStore = class {
+  repositoryRoot;
+  factsDirectory;
+  summariesDirectory;
+  constructor(repositoryRoot = process.cwd()) {
+    this.repositoryRoot = resolve2(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, dirname2(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, dirname2(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) {
+    const path = pathOrId.endsWith(".md") ? this.safePath(pathOrId) : this.factPath(pathOrId);
+    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) => this.readFact(path)
+    );
+    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 };
+  }
+  async scan(directory, managedName, read) {
+    try {
+      await this.prepareDirectory(directory);
+      const entries = await readdir(directory, { withFileTypes: true });
+      const result = { items: [], invalid: [] };
+      for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
+        if (!entry.isFile() || !managedName.test(entry.name)) continue;
+        const path = join(directory, entry.name);
+        try {
+          const item = await read(path);
+          const id = entry.name.slice(0, -".md".length);
+          if (item.id !== id)
+            throw new Error(`file ID ${id} differs from front matter ID ${item.id}`);
+          result.items.push(item);
+        } catch (error) {
+          result.invalid.push({
+            id: entry.name.slice(0, -".md".length),
+            path,
+            error: error.message.split("\n")[0]?.slice(0, 300) ?? "unreadable"
+          });
+        }
+      }
+      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 = resolve2(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, dirname2(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/core/worker.ts
+var DEFAULT_POLL_MS = 250;
+var DEFAULT_BATCH_SIZE = 8;
+var DEFAULT_MAX_ATTEMPTS = 5;
+var ERROR_BACKOFF_MS = 2e3;
+var EmbeddingWorker = class {
+  repo;
+  provider;
+  pollIntervalMs;
+  batchSize;
+  maxAttempts;
+  onDiagnostic;
+  state = "idle";
+  loopPromise = null;
+  wake = null;
+  idleResolvers = [];
+  inFlight = 0;
+  constructor(options) {
+    this.repo = options.repository;
+    this.provider = options.provider;
+    this.pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_MS;
+    this.batchSize = options.batchSize ?? DEFAULT_BATCH_SIZE;
+    this.maxAttempts = options.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
+    this.onDiagnostic = options.onDiagnostic;
+  }
+  getState() {
+    return this.state;
+  }
+  start() {
+    if (this.loopPromise !== null) return;
+    this.state = "running";
+    this.loopPromise = this.loop().finally(() => {
+      this.loopPromise = null;
+      if (this.state === "running") this.state = "idle";
+    });
+    this.loopPromise.catch(() => {
+    });
+  }
+  notify() {
+    if (this.state === "idle" && this.loopPromise === null) this.start();
+    if (this.wake) {
+      const fn = this.wake;
+      this.wake = null;
+      fn();
+    }
+  }
+  /**
+   * Resolve once the worker reaches an empty poll (no in-flight jobs and
+   * nothing left to claim). Retained for API compatibility: with
+   * repository-side leases and backoff there is no unbounded claim window to
+   * wait out anymore.
+   */
+  async drain() {
+    await new Promise((resolve3) => {
+      this.idleResolvers.push(resolve3);
+      this.notify();
+    });
+  }
+  async stop() {
+    if (this.state === "stopped" || this.state === "idle") {
+      this.state = "stopped";
+      return;
+    }
+    this.state = "draining";
+    this.notify();
+    if (this.loopPromise) {
+      await this.loopPromise;
+    }
+    this.state = "stopped";
+  }
+  async shutdown() {
+    await this.stop();
+  }
+  getInFlight() {
+    return this.inFlight;
+  }
+  async loop() {
+    while (this.state === "running") {
+      let jobs;
+      try {
+        jobs = await this.repo.claimPendingEmbeddings(this.batchSize);
+      } catch (error) {
+        console.error(
+          `[worker] claimPendingEmbeddings failed: ${error instanceof Error ? error.message : String(error)}; retrying`
+        );
+        if (this.state !== "running") break;
+        await new Promise((resolve3) => setTimeout(resolve3, ERROR_BACKOFF_MS));
+        continue;
+      }
+      if (jobs.length === 0) {
+        this.flushIdleResolvers();
+        if (this.state !== "running") break;
+        await this.sleep();
+        continue;
+      }
+      this.inFlight += jobs.length;
+      try {
+        const outcomes = await Promise.allSettled(jobs.map((job) => this.processJob(job)));
+        for (const outcome of outcomes) {
+          if (outcome.status === "rejected") {
+            console.error(`[worker] embedding job failed unexpectedly: ${String(outcome.reason)}`);
+          }
+        }
+      } finally {
+        this.inFlight -= jobs.length;
+      }
+    }
+    this.flushIdleResolvers();
+  }
+  flushIdleResolvers() {
+    if (this.inFlight > 0) return;
+    const resolvers = this.idleResolvers;
+    this.idleResolvers = [];
+    for (const resolve3 of resolvers) resolve3();
+  }
+  async processJob(job) {
+    let leaseLost = false;
+    const renewal = setInterval(
+      () => {
+        void this.repo.renewEmbeddingLease(job.id, job.leaseToken).then((renewed) => {
+          if (!renewed) leaseLost = true;
+        }).catch(() => {
+          leaseLost = true;
+        });
+      },
+      Math.max(250, Math.floor(job.leaseMs / 3))
+    );
+    try {
+      const response = await this.provider.embed({
+        input: job.content,
+        model: job.embeddingModel
+      });
+      validateEmbeddingResponse(response, 1);
+      const vector2 = response.vectors[0];
+      if (!vector2 || vector2.length === 0) {
+        throw new Error("Provider returned no embedding vector.");
+      }
+      if (leaseLost || !await this.repo.markEmbeddingReady(
+        job.id,
+        job.leaseToken,
+        vector2,
+        response.model,
+        embeddingSpaceKey(embeddingSpace(response))
+      ))
+        return;
+      await this.emitDiagnostic({
+        id: generateEntityId("mc"),
+        namespaceId: job.namespaceId,
+        metadata: {
+          model: response.model,
+          type: "embedding",
+          status: "success",
+          latencyMs: 0,
+          retries: 0,
+          fallbackTriggered: false,
+          coldStartWaitMs: 0
+        }
+      });
+    } catch (error) {
+      const attempts = job.attempts + 1;
+      const message = error instanceof Error ? error.message : String(error);
+      if (leaseLost) return;
+      try {
+        if (!await this.repo.markEmbeddingFailed(job.id, job.leaseToken, message, attempts, {
+          maxAttempts: this.maxAttempts
+        }))
+          return;
+      } catch (persistenceError) {
+        console.error(
+          `[worker] could not persist embedding failure: ${persistenceError instanceof Error ? persistenceError.message : String(persistenceError)}`
+        );
+        return;
+      }
+      await this.emitDiagnostic({
+        id: generateEntityId("mc"),
+        namespaceId: job.namespaceId,
+        metadata: {
+          model: job.embeddingModel,
+          type: "embedding",
+          status: attempts >= this.maxAttempts ? "failed" : "fallback",
+          latencyMs: 0,
+          error: message,
+          retries: attempts,
+          fallbackTriggered: false,
+          coldStartWaitMs: 0
+        }
+      });
+    } finally {
+      clearInterval(renewal);
+    }
+  }
+  emitDiagnostic(entry) {
+    const sink = this.onDiagnostic;
+    if (!sink) return Promise.resolve();
+    return Promise.resolve().then(() => sink(entry)).catch(() => {
+    });
+  }
+  sleep(ms) {
+    return new Promise((resolve3) => {
+      const timer = setTimeout(() => {
+        this.wake = null;
+        resolve3();
+      }, ms ?? this.pollIntervalMs);
+      this.wake = () => {
+        clearTimeout(timer);
+        resolve3();
+      };
+    });
+  }
+};
+
+// src/core/codebuddy.ts
+var RECALL_EMBED_TIMEOUT_MS = 1e4;
+var CodeBuddy = class {
+  config;
+  repo;
+  provider;
+  worker;
+  policy;
+  tracer;
+  memoryFileStore;
+  namespaceId = null;
+  initialized = false;
+  constructor(config, deps) {
+    this.config = validateConfig(config);
+    if (!deps?.repository) {
+      throw new Error(
+        "CodeBuddy requires a MemoryRepository. Pass deps.repository (use createPostgresRepository for production)."
+      );
+    }
+    this.repo = deps.repository;
+    this.memoryFileStore = deps.memoryFileStore;
+    this.provider = deps.provider ?? buildProviderFromConfig(this.config.provider);
+    this.worker = deps.worker ?? new EmbeddingWorker({
+      repository: this.repo,
+      provider: this.provider,
+      ...this.config.worker?.pollIntervalMs !== void 0 ? { pollIntervalMs: this.config.worker.pollIntervalMs } : {},
+      ...this.config.worker?.batchSize !== void 0 ? { batchSize: this.config.worker.batchSize } : {},
+      ...this.config.worker?.maxAttempts !== void 0 ? { maxAttempts: this.config.worker.maxAttempts } : {}
+    });
+    this.policy = deps.policy ?? new DefaultPolicy();
+    this.tracer = deps.tracer ?? createTracer();
+  }
+  async init(options = {}) {
+    const namespace = await this.repo.ensureNamespace(this.config.namespace);
+    this.namespaceId = namespace.id;
+    this.initialized = true;
+    if (options.startWorker !== false) this.worker.start();
+    return {
+      ready: true,
+      phase: "runtime",
+      message: `CodeBuddy ready in namespace ${namespace.name}.`,
+      namespaceId: namespace.id
+    };
+  }
+  async shutdown() {
+    await this.worker.shutdown();
+  }
+  getWorker() {
+    return this.worker;
+  }
+  async remember(input) {
+    const namespaceId = this.requireNamespaceId();
+    const type = input.type ?? "interaction";
+    const sessionId = input.sessionId ?? generateSessionId();
+    const content = input.content;
+    if (!content || content.length === 0) {
+      throw new Error("remember: content must not be empty.");
+    }
+    const result = await this.repo.withSessionLock(
+      namespaceId,
+      sessionId,
+      () => this.writeOne({
+        namespaceId,
+        sessionId,
+        type,
+        content,
+        idempotencyKey: input.idempotencyKey,
+        ...input.agentId !== void 0 ? { agentId: input.agentId } : {}
+      })
+    );
+    this.worker.notify();
+    return {
+      id: result.id,
+      sessionId: result.sessionId,
+      deduplicated: result.deduplicated
+    };
+  }
+  async rememberBatch(items) {
+    if (!Array.isArray(items) || items.length === 0) return [];
+    const results = [];
+    for (const item of items) {
+      results.push(await this.remember(item));
+    }
+    return results;
+  }
+  async recall(input) {
+    const namespaceId = this.requireNamespaceId();
+    if (!input.query || input.query.length === 0) {
+      throw new Error("recall: query must not be empty.");
+    }
+    const requested = input.budget ?? this.config.tokenBudget ?? 4e3;
+    const clamp = clampBudgetForCallerModel(requested, input.callerModel);
+    const queryEmbedding = await this.embedQueryWithFallback(input.query);
+    const planInput = {
+      namespace: this.config.namespace,
+      namespaceId,
+      sessionId: input.sessionId,
+      query: input.query,
+      budget: clamp.budget,
+      conflictMode: input.conflictMode ?? "all",
+      queryEmbedding,
+      repository: this.repo,
+      ...input.callerModel !== void 0 ? { callerModel: input.callerModel } : {}
+    };
+    const planned = await this.tracer.withSpan(
+      "codebuddy.recall",
+      {
+        namespace: this.config.namespace,
+        sessionId: input.sessionId,
+        budget: clamp.budget,
+        conflictMode: planInput.conflictMode,
+        callerModel: input.callerModel ?? null
+      },
+      () => this.policy.plan(planInput)
+    );
+    planned.stats.budgetClamped = clamp.clamped;
+    if (clamp.clamped && clamp.reason) {
+      planned.stats.budgetClampReason = clamp.reason;
+    }
+    return planned;
+  }
+  /**
+   * Dense evidence for file facts supplied by the context engine: the cosine of
+   * each fact whose stored vector clears the embedding model's calibrated
+   * `relevanceFloor` against the task (exact pgvector search over the
+   * namespace). Facts below the floor, of unknown models, or on any failure or
+   * timeout are simply absent, so callers fall back to lexical evidence.
+   */
+  async rankContextFacts(task, factIds, options = {}) {
+    if (!task.trim() || factIds.length === 0) return {};
+    const allowed = new Set(factIds.slice(0, 256));
+    try {
+      return await pTimeout2(
+        (async () => {
+          const query = await this.embedQueryWithFallback(task.slice(0, 4096));
+          const floor = query ? this.config.provider.relevanceFloor ?? getModelDefinition(query.space.model)?.relevanceFloor : void 0;
+          if (!query || floor === void 0) return {};
+          const result = await this.repo.searchSimilarEmbeddings({
+            namespaceId: this.requireNamespaceId(),
+            vector: query.vector,
+            embeddingSpace: embeddingSpaceKey(query.space),
+            embeddingModel: query.space.model,
+            limit: 256
+          });
+          const scores = {};
+          for (const row of result.candidates) {
+            if (row.ownerType === "fact" && allowed.has(row.ownerId) && Number.isFinite(row.score) && row.score >= floor) {
+              scores[row.ownerId] = Math.max(scores[row.ownerId] ?? 0, Math.min(1, row.score));
+            }
+          }
+          return scores;
+        })(),
+        { milliseconds: options.timeoutMs ?? 1500 }
+      );
+    } catch {
+      return {};
+    }
+  }
+  async embedQueryWithFallback(query) {
+    try {
+      const response = await this.tracer.withSpan(
+        "codebuddy.recall.embed_query",
+        { length: query.length },
+        () => pTimeout2(this.provider.embed({ input: query }), {
+          milliseconds: RECALL_EMBED_TIMEOUT_MS
+        })
+      );
+      validateEmbeddingResponse(response, 1);
+      const vector2 = response.vectors[0];
+      return vector2 ? { vector: vector2, space: embeddingSpace(response) } : null;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Share facts owned by the configured namespace. A reference is a live grant
+   * recorded durably in the source fact's Markdown (`sharedWith`); a snapshot is
+   * a copy owned by the target and written to the target project's own store.
+   */
+  async share(input) {
+    if (!input.from || !input.to) {
+      throw new Error("share: both 'from' and 'to' namespaces are required.");
+    }
+    if (input.from === input.to) {
+      throw new Error("share: 'from' and 'to' must differ.");
+    }
+    const fromNamespaceId = this.requireNamespaceId();
+    if (input.from !== this.config.namespace) {
+      throw new Error(
+        `share: only facts of the configured namespace "${this.config.namespace}" can be shared.`
+      );
+    }
+    if (!Array.isArray(input.factIds) || input.factIds.length === 0) {
+      return { shared: 0 };
+    }
+    const mode = input.mode ?? "reference";
+    let targetStore;
+    if (mode === "snapshot") {
+      if (input.targetProjectRoot) {
+        targetStore = await resolveTargetStore(input.targetProjectRoot, input.to);
+      } else if (this.memoryFileStore) {
+        throw new Error(
+          "share: snapshot mode requires targetProjectRoot so the copy is durable in the target project's Markdown store."
+        );
+      }
+    }
+    const toNs = await this.repo.ensureNamespace(input.to);
+    let shared = 0;
+    const embeddingModel = DEFAULT_EMBEDDING_MODELS[0]?.id ?? "unknown";
+    for (const factId of input.factIds) {
+      const auditId = generateEntityId("aud");
+      const shareId = generateEntityId("shr");
+      const source = await this.repo.getFactById(fromNamespaceId, factId);
+      if (!source) {
+        throw new Error(`share: fact ${factId} not found in namespace "${input.from}".`);
+      }
+      if (mode === "reference") {
+        const write = {
+          id: shareId,
+          fromNamespaceId,
+          toNamespaceId: toNs.id,
+          sourceFactId: factId,
+          mode: "reference",
+          ...input.agentId !== void 0 ? { createdByAgent: input.agentId } : {}
+        };
+        await this.repo.shareReference(write);
+        await this.updateSharedWith(factId, (current) => [...current, toNs.name]);
+      } else {
+        const snapshotContent = [
+          `[shared from ${input.from}] ${source.subject} ${source.predicate} ${source.object}`,
+          source.content
+        ].join("\n");
+        const snapshotFactId = generateEntityId("fact");
+        const snapshotEmbeddingId = generateEntityId("emb");
+        const snapshotFact = {
+          id: snapshotFactId,
+          namespaceId: toNs.id,
+          content: snapshotContent,
+          contentHash: computeFactHash(toNs.name, snapshotContent),
+          subject: source.subject,
+          predicate: "snapshot_of",
+          object: `${input.from}:${factId}`,
+          ...input.agentId !== void 0 ? { createdByAgent: input.agentId } : {}
+        };
+        const embedding = {
+          id: snapshotEmbeddingId,
+          namespaceId: toNs.id,
+          ownerType: "fact",
+          ownerId: snapshotFactId,
+          embeddingModel
+        };
+        const write = {
+          id: shareId,
+          fromNamespaceId,
+          toNamespaceId: toNs.id,
+          sourceFactId: factId,
+          mode: "snapshot",
+          snapshotFactId,
+          ...input.agentId !== void 0 ? { createdByAgent: input.agentId } : {}
+        };
+        const result = await this.repo.shareSnapshot({ share: write, snapshotFact, embedding });
+        if (targetStore)
+          await writeSnapshotFile(this.repo, targetStore, toNs, result.snapshotFactId);
+      }
+      const audit = {
+        id: auditId,
+        namespaceId: fromNamespaceId,
+        action: "share",
+        entityType: "fact",
+        entityId: factId,
+        ...input.agentId !== void 0 ? { createdByAgent: input.agentId } : {},
+        metadata: { mode, toNamespace: toNs.name, shareId }
+      };
+      await this.repo.recordAudit(audit);
+      shared += 1;
+    }
+    this.worker.notify();
+    return { shared };
+  }
+  /** Revoke live reference shares of configured-namespace facts to `to`. */
+  async unshare(input) {
+    const fromNamespaceId = this.requireNamespaceId();
+    const toNs = await this.repo.getNamespaceByName(input.to);
+    if (!toNs || input.factIds.length === 0) return { revoked: 0 };
+    const revoked = await this.repo.revokeShares(fromNamespaceId, toNs.id, input.factIds);
+    for (const factId of input.factIds) {
+      await this.updateSharedWith(factId, (current) => current.filter((ns) => ns !== toNs.name));
+    }
+    if (revoked > 0) {
+      await this.repo.recordAudit({
+        id: generateEntityId("aud"),
+        namespaceId: fromNamespaceId,
+        action: "share",
+        entityType: "fact",
+        ...input.agentId !== void 0 ? { createdByAgent: input.agentId } : {},
+        metadata: { mode: "reference", toNamespace: toNs.name, revoked: input.factIds }
+      });
+    }
+    return { revoked };
+  }
+  /** Keep the source fact's durable `sharedWith` list in step with the shares table. */
+  async updateSharedWith(factId, next) {
+    if (!this.memoryFileStore) return;
+    let file;
+    try {
+      file = await this.memoryFileStore.readFact(factId);
+    } catch (error) {
+      if (error.code === "ENOENT") return;
+      throw error;
+    }
+    if (file.namespace !== this.config.namespace) return;
+    await this.memoryFileStore.setFactSharedWith(factId, next(file.sharedWith));
+  }
+  async forget(id) {
+    if (!id) throw new Error("forget: id is required.");
+    const namespaceId = this.requireNamespaceId();
+    const interactionAudit = {
+      id: generateEntityId("aud"),
+      namespaceId,
+      action: "forget",
+      entityType: "interaction",
+      entityId: id
+    };
+    const interactionResult = await this.repo.withSessionLock(
+      namespaceId,
+      REINDEX_LOCK_KEY,
+      async () => {
+        const existing = await this.repo.getInteractionsByIds(namespaceId, [id]);
+        if (existing.length === 0) return { found: false, sourceDeletedFactIds: [] };
+        await this.memoryFileStore?.markSourceInteractionDeleted(this.config.namespace, id);
+        return this.repo.forgetInteraction(namespaceId, id, interactionAudit);
+      }
+    );
+    if (interactionResult.found) {
+      for (const factId of interactionResult.sourceDeletedFactIds) {
+        const file = await this.memoryFileStore?.readFact(factId).catch(() => null);
+        if (file?.namespace === this.config.namespace) {
+          await this.memoryFileStore?.markFactSourceDeleted(factId);
+        }
+      }
+      return { ok: true, entityType: "interaction" };
+    }
+    const factAudit = {
+      id: generateEntityId("aud"),
+      namespaceId,
+      action: "forget",
+      entityType: "fact",
+      entityId: id
+    };
+    const factResult = await this.repo.withSessionLock(namespaceId, REINDEX_LOCK_KEY, async () => {
+      const result = await this.repo.forgetFact(namespaceId, id, factAudit);
+      if (result.found) {
+        const file = await this.memoryFileStore?.readFact(id).catch(() => null);
+        if (file?.namespace === this.config.namespace) await this.memoryFileStore?.deleteFact(id);
+      }
+      return result;
+    });
+    if (factResult.found) return { ok: true, entityType: "fact" };
+    return { ok: false, entityType: "unknown" };
+  }
+  /**
+   * Reconcile the derived database with the Markdown memory files (the source
+   * of truth) for this namespace: upsert by stable ID, preserving the file's
+   * lifecycle metadata; re-embed only changed content; delete rows whose file
+   * is gone. Only rows a reindex previously imported from Markdown
+   * (`file_backed`) are ever deleted, so DB-only legacy memory survives. Each
+   * file is applied independently: malformed or conflicting files are reported
+   * in `failures` and never abort healthy imports (nor count as deletions).
+   */
+  async reindexMemory() {
+    const namespaceId = this.requireNamespaceId();
+    const store = this.memoryFileStore;
+    if (!store) {
+      throw new Error("Fact reindexing requires a repository-rooted MemoryFileStore.");
+    }
+    const namespace = this.config.namespace;
+    const result = await this.repo.withSessionLock(namespaceId, REINDEX_LOCK_KEY, async () => {
+      const [factScan, summaryScan] = await Promise.all([store.scanFacts(), store.scanSummaries()]);
+      const facts2 = factScan.facts.filter((file) => isEligibleMemory(file, { namespace }));
+      const summaries = summaryScan.summaries.filter((file) => file.namespace === namespace);
+      const failures = [
+        ...factScan.invalid.map((file) => ({ kind: "fact", ...file })),
+        ...summaryScan.invalid.map((file) => ({ kind: "summary", ...file }))
+      ];
+      const factCounts = emptyCounts(
+        facts2.length + factScan.invalid.length,
+        factScan.invalid.length
+      );
+      const summaryCounts = emptyCounts(
+        summaries.length + summaryScan.invalid.length,
+        summaryScan.invalid.length
+      );
+      const apply = async (kind, file, counts, write) => {
+        try {
+          const { status } = await write();
+          counts[status === "inserted" ? "imported" : status] += 1;
+          return true;
+        } catch (error) {
+          counts.failed += 1;
+          failures.push({ kind, id: file.id, path: file.path, error: describeError(error) });
+          return false;
+        }
+      };
+      const present = /* @__PURE__ */ new Set([
+        ...facts2.map((file) => file.id),
+        ...summaries.map((file) => file.id),
+        ...factScan.invalid.map((file) => file.id),
+        ...summaryScan.invalid.map((file) => file.id)
+      ]);
+      const owned = await this.repo.listFileBackedIds(namespaceId);
+      for (const id of owned.facts.filter((id2) => !present.has(id2))) {
+        const removed = await this.repo.forgetFact(
+          namespaceId,
+          id,
+          reindexAudit(namespaceId, "fact", id)
+        );
+        if (removed.found) factCounts.deleted += 1;
+      }
+      for (const id of owned.summaries.filter((id2) => !present.has(id2))) {
+        const removed = await this.repo.forgetSummary(
+          namespaceId,
+          id,
+          reindexAudit(namespaceId, "summary", id)
+        );
+        if (removed.found) summaryCounts.deleted += 1;
+      }
+      for (const file of facts2) {
+        const imported = await apply(
+          "fact",
+          file,
+          factCounts,
+          () => this.importFactFile(namespaceId, file)
+        );
+        if (imported) await this.restoreShares(namespaceId, file);
+      }
+      for (const file of summaries) {
+        await apply(
+          "summary",
+          file,
+          summaryCounts,
+          () => this.importSummaryFile(namespaceId, file)
+        );
+      }
+      return {
+        facts: factCounts,
+        summaries: summaryCounts,
+        failures: failures.slice(0, MAX_REPORTED_FAILURES)
+      };
+    });
+    const space = this.provider.space;
+    const canEmbed = space !== void 0 && await this.provider.embed({ input: "codebuddy" }).then(
+      () => true,
+      () => false
+    );
+    const reembedding = space && canEmbed ? await this.repo.requeueEmbeddingsOutsideSpace(namespaceId, embeddingSpaceKey(space)) : 0;
+    this.worker.notify();
+    return { ...result, reembedding };
+  }
+  async reindexFacts() {
+    return (await this.reindexMemory()).facts;
+  }
+  requireNamespaceId() {
+    if (!this.initialized || !this.namespaceId) {
+      throw new Error("CodeBuddy.init() must complete before this method is called.");
+    }
+    return this.namespaceId;
+  }
+  async writeOne(input) {
+    const embeddingModel = DEFAULT_EMBEDDING_MODELS[0]?.id ?? "unknown";
+    const ownerId = generateEntityId(prefixForType(input.type));
+    const claim = redactPersisted({
+      subject: "__inline__",
+      predicate: "asserts",
+      object: input.content.slice(0, 200),
+      content: input.content
+    });
+    const content = input.type === "fact" ? claim.content : input.content;
+    const contentHash = input.idempotencyKey ?? (input.type === "fact" ? factContentHash(this.config.namespace, ownerId, content) : computeContentHash(this.config.namespace, input.sessionId, input.content));
+    const tokenCount = estimateTokenCount(content);
+    const embeddingId = generateEntityId("emb");
+    const embedding = {
+      id: embeddingId,
+      namespaceId: input.namespaceId,
+      ownerType: input.type,
+      ownerId,
+      embeddingModel
+    };
+    const audit = {
+      id: generateEntityId("aud"),
+      namespaceId: input.namespaceId,
+      action: "remember",
+      entityType: input.type,
+      entityId: ownerId,
+      ...input.agentId !== void 0 ? { createdByAgent: input.agentId } : {},
+      metadata: { sessionId: input.sessionId, type: input.type }
+    };
+    if (input.type === "interaction") {
+      const interaction = {
+        id: ownerId,
+        namespaceId: input.namespaceId,
+        sessionId: input.sessionId,
+        content: input.content,
+        contentHash,
+        tokenCount,
+        ...input.agentId !== void 0 ? { createdByAgent: input.agentId } : {}
+      };
+      return this.repo.writeInteraction({ interaction, embedding, audit });
+    }
+    if (input.type === "fact") {
+      const fact = {
+        id: ownerId,
+        namespaceId: input.namespaceId,
+        content,
+        contentHash,
+        subject: claim.subject,
+        predicate: claim.predicate,
+        object: claim.object,
+        ...input.agentId !== void 0 ? { createdByAgent: input.agentId } : {}
+      };
+      const result2 = await this.repo.writeFact({ fact, embedding, audit });
+      if (this.memoryFileStore) {
+        if (result2.deduplicated) {
+          try {
+            await this.memoryFileStore.readFact(result2.id);
+            return result2;
+          } catch (error) {
+            if (error.code !== "ENOENT") throw error;
+          }
+        }
+        await this.memoryFileStore.writeFact({
+          id: result2.id,
+          namespace: this.config.namespace,
+          subject: fact.subject,
+          predicate: fact.predicate,
+          object: fact.object,
+          confidence: 1,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          createdByAgent: input.agentId ?? null,
+          sourceInteractionId: fact.sourceInteractionId ?? null,
+          sourceDeleted: false,
+          content: fact.content
+        });
+      }
+      return result2;
+    }
+    const summary = {
+      id: ownerId,
+      namespaceId: input.namespaceId,
+      sessionId: input.sessionId,
+      content: input.content,
+      tokenCount,
+      ...input.agentId !== void 0 ? { createdByAgent: input.agentId } : {}
+    };
+    const result = await this.repo.writeSummary({ summary, embedding, audit });
+    if (this.memoryFileStore) {
+      if (result.deduplicated) {
+        try {
+          await this.memoryFileStore.readSummary(result.id);
+          return result;
+        } catch (error) {
+          if (error.code !== "ENOENT") throw error;
+        }
+      }
+      await this.memoryFileStore.writeSummary({
+        id: result.id,
+        namespace: this.config.namespace,
+        sessionId: result.sessionId,
+        version: summary.version ?? 1,
+        tokenCount: summary.tokenCount,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        createdByAgent: input.agentId ?? null,
+        content: summary.content
+      });
+    }
+    return result;
+  }
+  async restoreShares(namespaceId, file) {
+    for (const to of file.sharedWith) {
+      if (to === this.config.namespace) continue;
+      const toNs = await this.repo.ensureNamespace(to);
+      await this.repo.shareReference({
+        id: generateEntityId("shr"),
+        fromNamespaceId: namespaceId,
+        toNamespaceId: toNs.id,
+        sourceFactId: file.id,
+        mode: "reference"
+      });
+    }
+  }
+  importFactFile(namespaceId, file) {
+    return this.repo.upsertFactFromFile({
+      fact: {
+        id: file.id,
+        namespaceId,
+        content: file.content,
+        contentHash: factContentHash(this.config.namespace, file.id, file.content),
+        subject: file.subject,
+        predicate: file.predicate,
+        object: file.object,
+        confidence: file.confidence,
+        sourceInteractionId: file.sourceInteractionId ?? void 0,
+        sourceDeleted: file.sourceDeleted,
+        supersededBy: file.supersededBy,
+        propositionKey: file.propositionKey ?? null,
+        createdByAgent: file.createdByAgent ?? void 0,
+        createdAt: new Date(file.createdAt)
+      },
+      embedding: pendingEmbedding(namespaceId, "fact", file.id),
+      audit: {
+        id: generateEntityId("aud"),
+        namespaceId,
+        action: "remember",
+        entityType: "fact",
+        entityId: file.id,
+        metadata: { source: "reindex", path: file.path }
+      }
+    });
+  }
+  importSummaryFile(namespaceId, file) {
+    return this.repo.upsertSummaryFromFile({
+      summary: {
+        id: file.id,
+        namespaceId,
+        sessionId: file.sessionId,
+        content: file.content,
+        version: file.version,
+        tokenCount: file.tokenCount,
+        createdByAgent: file.createdByAgent ?? void 0,
+        createdAt: new Date(file.createdAt)
+      },
+      embedding: pendingEmbedding(namespaceId, "summary", file.id),
+      audit: {
+        id: generateEntityId("aud"),
+        namespaceId,
+        action: "remember",
+        entityType: "summary",
+        entityId: file.id,
+        metadata: { source: "reindex", path: file.path }
+      }
+    });
+  }
+};
+async function resolveTargetStore(root, namespace) {
+  const resolved = (await readConfigFile(root)).namespace ?? defaultNamespaceForCwd(root);
+  if (resolved !== namespace) {
+    throw new Error(
+      `share: targetProjectRoot ${root} resolves to namespace "${resolved}", not "${namespace}".`
+    );
+  }
+  return new MemoryFileStore(root);
+}
+async function writeSnapshotFile(repo, store, namespace, factId) {
+  try {
+    await store.readFact(factId);
+    return;
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+  const fact = await repo.getFactById(namespace.id, factId);
+  if (!fact)
+    throw new Error(`share: snapshot ${factId} missing from namespace "${namespace.name}".`);
+  await store.writeFact({
+    id: fact.id,
+    namespace: namespace.name,
+    subject: fact.subject,
+    predicate: fact.predicate,
+    object: fact.object,
+    confidence: fact.confidence,
+    createdAt: fact.createdAt.toISOString(),
+    createdByAgent: fact.createdByAgent,
+    sourceInteractionId: null,
+    sourceDeleted: false,
+    content: fact.content
+  });
+}
+var REINDEX_LOCK_KEY = "__codebuddy_markdown_reindex__";
+var MAX_REPORTED_FAILURES = 50;
+function emptyCounts(scanned, failed) {
+  return { scanned, imported: 0, updated: 0, unchanged: 0, deleted: 0, failed };
+}
+function pendingEmbedding(namespaceId, ownerType, ownerId) {
+  return {
+    id: generateEntityId("emb"),
+    namespaceId,
+    ownerType,
+    ownerId,
+    embeddingModel: DEFAULT_EMBEDDING_MODELS[0]?.id ?? "unknown"
+  };
+}
+function reindexAudit(namespaceId, entityType, entityId) {
+  return {
+    id: generateEntityId("aud"),
+    namespaceId,
+    action: "forget",
+    entityType,
+    entityId,
+    metadata: { source: "reindex", reason: "no eligible markdown file" }
+  };
+}
+function describeError(error) {
+  const cause = error.cause;
+  const message = cause instanceof Error ? cause.message : error.message;
+  return String(message).split("\n")[0]?.slice(0, 300) ?? "unknown error";
+}
+function factContentHash(namespace, id, content) {
+  return computeFactHash(namespace, content === REDACTED ? `${REDACTED}${id}` : content);
+}
+function prefixForType(type) {
+  if (type === "interaction") return "int";
+  if (type === "fact") return "fact";
+  return "sum";
+}
+function estimateTokenCount(content) {
+  return countTokens(content);
+}
+function buildProviderFromConfig(provider) {
+  if (provider.type === "local") return new LocalModelProvider();
+  if (provider.type === "openrouter") {
+    const model = provider.model ?? DEFAULT_CLOUD_EMBEDDING_MODELS.openrouter;
+    const apiKey = process.env.OPENROUTER_API_KEY;
+    if (!apiKey) return missingKeyProvider("OPENROUTER_API_KEY", model);
+    return new OpenRouterEmbeddingProvider({ apiKey, model });
+  }
+  return new HuggingFaceProvider({
+    ...provider.apiKey ? { apiKey: provider.apiKey } : {},
+    ...provider.model ? {
+      embeddingModels: [
+        {
+          id: provider.model,
+          role: "primary",
+          kind: "embedding",
+          dimensions: EMBEDDING_DIMENSIONS
+        }
+      ]
+    } : {}
+  });
+}
+function missingKeyProvider(variable, model) {
+  const fail = async () => {
+    throw new Error(
+      `${variable} is not set; ${model} cannot embed. Export it or run \`codebuddy models use local\`.`
+    );
+  };
+  return { embed: fail, generateText: fail };
+}
+
+// src/core/operations.ts
+async function createRuntime(config, options = {}) {
+  const runtimeConfig = config ?? await loadRuntimeConfig();
+  if (!runtimeConfig.postgresUrl) throw new Error(MISSING_DATABASE_URL);
+  const client = createDatabaseClient({
+    postgresUrl: runtimeConfig.postgresUrl,
+    ...options.connectTimeoutSeconds !== void 0 ? { connectTimeoutSeconds: options.connectTimeoutSeconds } : {}
+  });
+  try {
+    if (options.autoBootstrap) {
+      await bootstrapDatabase(client.sql);
+      await runMigrations(client);
+    }
+    const repository = createPostgresRepository(client);
+    const memory = new CodeBuddy(runtimeConfig, {
+      repository,
+      memoryFileStore: new MemoryFileStore(
+        options.repositoryRoot ?? runtimeConfig.projectRoot ?? process.cwd()
+      )
+    });
+    await memory.init(options.startWorker === false ? { startWorker: false } : {});
+    return {
+      memory,
+      repository,
+      async close() {
+        await memory.shutdown();
+        await client.close();
+      }
+    };
+  } catch (error) {
+    await client.close().catch(() => void 0);
+    throw error;
+  }
+}
+function encodeFactCursor(fact) {
+  return Buffer.from(JSON.stringify([fact.createdAt.toISOString(), fact.id]), "utf8").toString(
+    "base64url"
+  );
+}
+function decodeFactCursor(cursor) {
+  let parsed;
+  try {
+    parsed = JSON.parse(Buffer.from(cursor, "base64url").toString("utf8"));
+  } catch {
+    throw new Error("Invalid cursor: expected a base64url-encoded [createdAt, id] pair.");
+  }
+  if (!Array.isArray(parsed) || parsed.length !== 2 || typeof parsed[0] !== "string" || typeof parsed[1] !== "string" || Number.isNaN(Date.parse(parsed[0]))) {
+    throw new Error("Invalid cursor: expected a base64url-encoded [createdAt, id] pair.");
+  }
+  const [createdAt2, id] = parsed;
+  return { createdAt: new Date(createdAt2), id };
+}
+async function listFactsPage(memory, repository, input) {
+  const namespace = await repository.ensureNamespace(memory.config.namespace);
+  const requestedLimit = input.limit ?? 50;
+  const limit = Math.max(1, Math.min(100, requestedLimit));
+  const facts2 = await repository.listFacts({
+    namespaceId: namespace.id,
+    ...input.subject ? { subject: input.subject } : {},
+    limit: limit + 1,
+    ...input.cursor ? { cursor: decodeFactCursor(input.cursor) } : {}
+  });
+  const page = facts2.slice(0, limit);
+  const next = facts2.length > limit ? page.at(-1) : void 0;
+  return {
+    facts: page,
+    ...next ? { nextCursor: encodeFactCursor(next) } : {}
+  };
+}
+async function inspectNamespace(repository, namespace) {
+  if (!namespace) {
+    return {
+      namespaces: await repository.listNamespaces(),
+      agents: await repository.getAgentWriteBreakdown()
+    };
+  }
+  const row = await repository.getNamespaceByName(namespace);
+  if (!row) return { namespace, exists: false, facts: [], agents: [] };
+  return {
+    namespace,
+    exists: true,
+    facts: await repository.listFacts({ namespaceId: row.id, limit: 50 }),
+    agents: await repository.getAgentWriteBreakdown(row.id)
+  };
+}
+async function runDoctor(options = {}) {
+  const fileConfig = await readConfigFile();
+  const scaffold = await checkProjectScaffold();
+  const configPermissions = await checkConfigPermissions();
+  const expectedDefaultNamespace = defaultNamespaceForCwd();
+  const runtimeNamespace = process.env.CODEBUDDY_NAMESPACE ?? fileConfig.namespace ?? options.config?.namespace ?? null;
+  const namespaceReport = {
+    expectedDefault: expectedDefaultNamespace,
+    configured: fileConfig.namespace ?? null,
+    runtime: runtimeNamespace,
+    ok: !fileConfig.namespace || fileConfig.namespace === expectedDefaultNamespace || process.env.CODEBUDDY_NAMESPACE !== void 0,
+    ...!fileConfig.namespace || fileConfig.namespace === expectedDefaultNamespace || process.env.CODEBUDDY_NAMESPACE !== void 0 ? {} : {
+      warning: `Configured namespace "${fileConfig.namespace}" differs from this folder's default "${expectedDefaultNamespace}". Confirm your MCP entries point at the intended namespace.`
+    }
+  };
+  let config = options.config;
+  if (!config) {
+    try {
+      config = await loadRuntimeConfig();
+    } catch (error) {
+      const message = String(redactSecrets(error.message));
+      return {
+        db: {
+          ok: false,
+          error: message,
+          canConnect: false,
+          postgresUrlSource: "missing"
+        },
+        pgvector: { ok: false, error: "Postgres is not configured yet." },
+        vectors: { count: 0, index: null, needsTuning: false },
+        models: await checkModels(options.provider, true),
+        usage: {
+          last60s: 0,
+          lastHour: 0,
+          last24h: 0,
+          estimatedDailyCapRemaining: 1e4,
+          warning80Percent: false
+        },
+        scaffold,
+        config: configPermissions,
+        namespace: namespaceReport
+      };
+    }
+  }
+  let repository = options.repository;
+  let close;
+  let db = { ok: true };
+  let pgvector = { ok: true };
+  if (!repository) {
+    const postgresUrlSource = options.config?.postgresUrl !== void 0 ? "explicit" : process.env.DATABASE_URL ? "environment" : fileConfig.postgresUrl ? "config" : "missing";
+    const client = createDatabaseClient({ postgresUrl: config.postgresUrl });
+    repository = createPostgresRepository(client);
+    close = () => client.close();
+    try {
+      const canConnect = await pingDatabase(client);
+      db = { ok: canConnect, canConnect, postgresUrlSource };
+      if (!canConnect) db.error = "Postgres did not respond to a simple ping.";
+    } catch (error) {
+      db = {
+        ok: false,
+        canConnect: false,
+        postgresUrlSource,
+        error: String(redactSecrets(error.message))
+      };
+    }
+    try {
+      const health = await checkPgvector(client.sql);
+      pgvector = {
+        ok: health.available,
+        ...health.available ? {} : { error: "pgvector extension is not installed." }
+      };
+    } catch (error) {
+      pgvector = { ok: false, error: String(redactSecrets(error.message)) };
+    }
+  }
+  try {
+    if (!db.ok) {
+      return {
+        db,
+        pgvector,
+        vectors: { count: 0, index: null, needsTuning: false },
+        models: await checkModels(options.provider, true),
+        usage: {
+          last60s: 0,
+          lastHour: 0,
+          last24h: 0,
+          estimatedDailyCapRemaining: 1e4,
+          warning80Percent: false
+        },
+        scaffold,
+        config: configPermissions,
+        namespace: namespaceReport
+      };
+    }
+    const namespace = await repository.ensureNamespace(config.namespace);
+    const [stats, vectorHealth] = await Promise.all([
+      repository.getStats(namespace.id),
+      repository.getVectorIndexHealth(namespace.id)
+    ]);
+    const models = await checkModels(options.provider, options.skipModelCheck);
+    const dailyCap = 1e4;
+    const used = stats.modelCalls.last24h;
+    return {
+      db,
+      pgvector,
+      vectors: {
+        count: vectorHealth.vectorCount,
+        index: vectorHealth.indexName,
+        needsTuning: vectorHealth.needsTuning
+      },
+      models,
+      usage: {
+        last60s: stats.modelCalls.last60s,
+        lastHour: stats.modelCalls.lastHour,
+        last24h: used,
+        estimatedDailyCapRemaining: Math.max(0, dailyCap - used),
+        warning80Percent: used >= dailyCap * 0.8
+      },
+      scaffold,
+      config: configPermissions,
+      namespace: namespaceReport
+    };
+  } finally {
+    await close?.();
+  }
+}
+async function checkModels(provider, skip = false) {
+  const ids = [...DEFAULT_EMBEDDING_MODELS, ...DEFAULT_LLM_MODELS].map((model) => model.id);
+  if (!provider || skip) {
+    return ids.map((id) => ({ id, reachable: false, status: "unknown" }));
+  }
+  const results = [];
+  for (const id of ids) {
+    try {
+      if (DEFAULT_EMBEDDING_MODELS.some((model) => model.id === id)) {
+        await provider.embed({ model: id, input: "doctor" });
+      } else {
+        await provider.generateText({ model: id, prompt: "doctor" });
+      }
+      results.push({ id, reachable: true, status: "warm" });
+    } catch (error) {
+      const message = String(redactSecrets(error.message));
+      results.push({
+        id,
+        reachable: false,
+        status: /gated|403/i.test(message) ? "gated" : /cold|503/i.test(message) ? "cold" : "failed",
+        error: message
+      });
+    }
+  }
+  return results;
+}
+
+export {
+  isEligibleMemory,
+  lexicalTerms,
+  embeddingSpaceKey,
+  DefaultPolicy,
+  HuggingFaceProvider,
+  isLangSmithTracingEnabled,
+  createTracer,
+  codeBuddyConfigSchema,
+  FACT_CATEGORIES,
+  INCIDENT_SEVERITIES,
+  MemoryFileStore,
+  EmbeddingWorker,
+  CodeBuddy,
+  buildProviderFromConfig,
+  bootstrapDatabase,
+  createDatabaseClient,
+  pingDatabase,
+  runMigrations,
+  createPostgresRepository,
+  createRuntime,
+  encodeFactCursor,
+  decodeFactCursor,
+  listFactsPage,
+  inspectNamespace,
+  runDoctor
+};
+//# sourceMappingURL=chunk-JDZ3VK26.js.map