@orquentra/codebuddy 2.5.0 → 2.6.2

package/dist/{chunk-JDZ3VK26.js → chunk-2XDPKFUW.js}

@@ -1,3 +1,19 @@
+import {
+  MemoryFileStore,
+  auditLog,
+  candidateLimit,
+  embeddings,
+  facts,
+  interactions,
+  isEligibleMemory,
+  lexicalTerms,
+  modelCalls,
+  namespaces,
+  schema_exports,
+  sessionSummaries,
+  shares,
+  validSearchVector
+} from "./chunk-S6VEG4S2.js";
 import {
   REDACTED,
   redactPersisted
@@ -9,13 +25,13 @@ import {
   countTokens,
   generateEntityId,
   generateSessionId
-} from "./chunk-4BYGTEJT.js";
+} from "./chunk-XBJQKCLU.js";
 import {
   OpenRouterEmbeddingProvider
-} from "./chunk-KYK6RPAJ.js";
+} from "./chunk-JFDRBPYF.js";
 import {
   LocalModelProvider
-} from "./chunk-3XYQGFPB.js";
+} from "./chunk-IBLJOHJL.js";
 import {
   DEFAULT_CLOUD_EMBEDDING_MODELS,
   DEFAULT_EMBEDDING_MODELS,
@@ -23,328 +39,24 @@ import {
   EMBEDDING_DIMENSIONS,
   assertCompatibleEmbeddingModels,
   getModelDefinition
-} from "./chunk-JMWJ7V6Y.js";
+} from "./chunk-JPHJBCZB.js";
 import {
   MISSING_DATABASE_URL,
-  assertNoSymlinkBetween,
   checkConfigPermissions,
   checkProjectScaffold,
-  composeMarkdown,
   defaultNamespaceForCwd,
   loadRuntimeConfig,
-  parseFrontMatter,
+  migrateLegacyNamespace,
   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
-    )
-  })
-);
+  redactSecrets
+} from "./chunk-5KZY6OTG.js";
 
 // src/db/bootstrap.ts
-async function enablePgvector(sql3) {
-  await sql3`create extension if not exists vector`;
+async function enablePgvector(sql2) {
+  await sql2`create extension if not exists vector`;
 }
-async function checkPgvector(sql3) {
-  const result = await sql3`
+async function checkPgvector(sql2) {
+  const result = await sql2`
     select extversion from pg_extension where extname = 'vector'
   `;
   return {
@@ -352,16 +64,30 @@ async function checkPgvector(sql3) {
     installedVersion: result[0]?.extversion ?? null
   };
 }
-async function bootstrapDatabase(sql3) {
-  await enablePgvector(sql3);
-  return checkPgvector(sql3);
+async function bootstrapDatabase(sql2) {
+  await withSchemaLock(sql2, () => enablePgvector(sql2));
+  return checkPgvector(sql2);
+}
+var SCHEMA_LOCK = 7310250421;
+async function withSchemaLock(sql2, work) {
+  const reserved = await sql2.reserve();
+  try {
+    await reserved`select pg_advisory_lock(${SCHEMA_LOCK}::bigint)`;
+    try {
+      return await work();
+    } finally {
+      await reserved`select pg_advisory_unlock(${SCHEMA_LOCK}::bigint)`;
+    }
+  } finally {
+    reserved.release();
+  }
 }
 
 // src/db/client.ts
 import { drizzle } from "drizzle-orm/postgres-js";
 import postgres from "postgres";
 function createDatabaseClient(config) {
-  const sql3 = postgres(config.postgresUrl, {
+  const sql2 = 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,
@@ -375,10 +101,10 @@ function createDatabaseClient(config) {
     }
   });
   return {
-    sql: sql3,
-    db: drizzle(sql3, { schema: schema_exports }),
+    sql: sql2,
+    db: drizzle(sql2, { schema: schema_exports }),
     async close() {
-      await sql3.end();
+      await sql2.end({ timeout: 2 });
     }
   };
 }
@@ -416,139 +142,13 @@ If this is an npm-installed package, make sure src/db/migrations was included in
 }
 async function runMigrations(client) {
   const migrationsFolder = resolveMigrationsFolder();
-  await migrate(client.db, { migrationsFolder });
+  await withSchemaLock(client.sql, () => 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));
-}
+import { and, desc, eq, inArray, isNull, lt, ne, or, sql } from "drizzle-orm";
 
 // src/providers/embedding-space.ts
 function embeddingSpace(response) {
@@ -566,12 +166,12 @@ function embeddingSpace(response) {
 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 validEmbeddingVector(vector, dimensions) {
+  return dimensions > 0 && vector.length === dimensions && vector.every(Number.isFinite);
 }
 function validateEmbeddingResponse(response, count) {
   embeddingSpace(response);
-  if (response.vectors.length !== count || response.vectors.some((vector2) => !validEmbeddingVector(vector2, response.dimensions))) {
+  if (response.vectors.length !== count || response.vectors.some((vector) => !validEmbeddingVector(vector, response.dimensions))) {
     throw new Error("Provider returned invalid embedding dimensions, values, or batch size.");
   }
 }
@@ -602,7 +202,7 @@ var PostgresMemoryRepository = class {
   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})`);
+      await tx.execute(sql`select pg_advisory_xact_lock(${k1}, ${k2})`);
       return this.sessionTransaction.run(tx, fn);
     });
   }
@@ -783,7 +383,7 @@ var PostgresMemoryRepository = class {
       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 tx.update(facts).set({ ...values, updatedAt: sql`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" };
@@ -852,12 +452,13 @@ var PostgresMemoryRepository = class {
    * 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) {
+  async claimPendingEmbeddings(limit, namespaceId) {
     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()))
+        where (status = 'pending'
+           or (status = 'processing' and (lease_until is null or lease_until < now())))
+          and (${namespaceId ?? null}::text is null or namespace_id = ${namespaceId ?? null})
         order by created_at asc
         for update skip locked
         limit ${limit}
@@ -896,33 +497,33 @@ var PostgresMemoryRepository = class {
     }));
   }
   async renewEmbeddingLease(id, leaseToken) {
-    const rows = await this.db.update(embeddings).set({ leaseUntil: sql2`now() + interval '120 seconds'` }).where(
+    const rows = await this.db.update(embeddings).set({ leaseUntil: sql`now() + interval '120 seconds'` }).where(
       and(
         eq(embeddings.id, id),
         eq(embeddings.leaseToken, leaseToken),
         eq(embeddings.status, "processing"),
-        sql2`${embeddings.leaseUntil} > now()`
+        sql`${embeddings.leaseUntil} > now()`
       )
     ).returning({ id: embeddings.id });
     return rows.length > 0;
   }
-  async markEmbeddingReady(id, leaseToken, vector2, model, space) {
-    const literal = `[${vector2.join(",")}]`;
+  async markEmbeddingReady(id, leaseToken, vector, model, space) {
+    const literal = `[${vector.join(",")}]`;
     const rows = await this.db.update(embeddings).set({
       status: "ready",
       vector: literal,
       embeddingModel: model,
-      embeddingSpace: space ?? embeddingSpaceKey(embeddingSpace({ model, dimensions: vector2.length })),
+      embeddingSpace: space ?? embeddingSpaceKey(embeddingSpace({ model, dimensions: vector.length })),
       lastError: null,
       leaseUntil: null,
       leaseToken: null,
-      updatedAt: sql2`now()`
+      updatedAt: sql`now()`
     }).where(
       and(
         eq(embeddings.id, id),
         eq(embeddings.leaseToken, leaseToken),
         eq(embeddings.status, "processing"),
-        sql2`${embeddings.leaseUntil} > now()`
+        sql`${embeddings.leaseUntil} > now()`
       )
     ).returning({ id: embeddings.id });
     return rows.length > 0;
@@ -938,18 +539,18 @@ var PostgresMemoryRepository = class {
     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`,
+      status: sql`case when ${attempts} >= ${maxAttempts} then 'failed'::embedding_status else 'processing'::embedding_status end`,
+      leaseUntil: sql`case when ${attempts} >= ${maxAttempts} then null else now() + (${backoffSeconds} || ' seconds')::interval end`,
       leaseToken: null,
       attempts,
       lastError: error,
-      updatedAt: sql2`now()`
+      updatedAt: sql`now()`
     }).where(
       and(
         eq(embeddings.id, id),
         eq(embeddings.leaseToken, leaseToken),
         eq(embeddings.status, "processing"),
-        sql2`${embeddings.leaseUntil} > now()`
+        sql`${embeddings.leaseUntil} > now()`
       )
     ).returning({ id: embeddings.id });
     return rows.length > 0;
@@ -1166,12 +767,12 @@ var PostgresMemoryRepository = class {
       lastError: null,
       leaseUntil: null,
       leaseToken: null,
-      updatedAt: sql2`now()`
+      updatedAt: sql`now()`
     }).where(
       and(
         eq(embeddings.namespaceId, namespaceId),
         inArray(embeddings.status, ["ready", "failed"]),
-        sql2`${embeddings.embeddingSpace} is distinct from ${space}`
+        sql`${embeddings.embeddingSpace} is distinct from ${space}`
       )
     ).returning({ id: embeddings.id });
     return rows.length;
@@ -1179,7 +780,7 @@ var PostgresMemoryRepository = class {
   async searchSimilarEmbeddings(input) {
     if (!validSearchVector(input.vector))
       return { method: "exact_pgvector", candidates: [], compatibleReady: 0 };
-    const rows = await this.db.execute(sql2`
+    const rows = await this.db.execute(sql`
       with compatible as materialized (
         select id, owner_type, owner_id, embedding_model, embedding_space, vector
         from embeddings
@@ -1188,7 +789,7 @@ var PostgresMemoryRepository = class {
             namespace_id = ${input.namespaceId}
             or (
               owner_type = 'fact'
-              and ${liveReference(input.namespaceId, sql2`embeddings.namespace_id`, sql2`embeddings.owner_id`)}
+              and ${liveReference(input.namespaceId, sql`embeddings.namespace_id`, sql`embeddings.owner_id`)}
             )
           )
           and embedding_space = ${input.embeddingSpace}
@@ -1224,7 +825,7 @@ var PostgresMemoryRepository = class {
   async searchFactsLexically(namespaceId, query, limit) {
     const terms = lexicalTerms(query);
     if (!terms.length) return { candidates: [], matchedFacts: 0 };
-    const rows = await this.db.execute(sql2`
+    const rows = await this.db.execute(sql`
       with scored as materialized (
         select id, content, subject, predicate, object, proposition_key, confidence,
           created_by_agent, created_at,
@@ -1238,7 +839,7 @@ var PostgresMemoryRepository = class {
         where not source_deleted and superseded_by is null
           and (
             namespace_id = ${namespaceId}
-            or ${liveReference(namespaceId, sql2`facts.namespace_id`, sql2`facts.id`)}
+            or ${liveReference(namespaceId, sql`facts.namespace_id`, sql`facts.id`)}
           )
       )
       select *, count(*) over () as total from scored where score > 0
@@ -1317,7 +918,7 @@ var PostgresMemoryRepository = class {
         isNull(facts.supersededBy),
         or(
           eq(facts.namespaceId, namespaceId),
-          liveReference(namespaceId, sql2`${facts.namespaceId}`, sql2`${facts.id}`)
+          liveReference(namespaceId, sql`${facts.namespaceId}`, sql`${facts.id}`)
         )
       )
     );
@@ -1576,11 +1177,11 @@ var PostgresMemoryRepository = class {
       limit 1
     `;
     const vectorCount = Number(countRows[0]?.count ?? 0);
-    const index2 = indexRows[0];
+    const index = indexRows[0];
     return {
       vectorCount,
-      indexName: index2?.indexname ?? null,
-      indexDefinition: index2?.indexdef ?? null,
+      indexName: index?.indexname ?? null,
+      indexDefinition: index?.indexdef ?? null,
       needsTuning: vectorCount >= 1e5
     };
   }
@@ -1624,7 +1225,7 @@ async function upsertPendingEmbedding(tx, embedding, reset) {
       lastError: null,
       leaseUntil: null,
       leaseToken: null,
-      updatedAt: sql2`now()`
+      updatedAt: sql`now()`
     }
   });
 }
@@ -1656,7 +1257,7 @@ var recentFactColumns = {
   createdAt: facts.createdAt
 };
 function liveReference(namespaceId, ownerNamespace, factId) {
-  return sql2`exists (
+  return sql`exists (
     select 1 from shares s
     where s.to_namespace_id = ${namespaceId}
       and s.from_namespace_id = ${ownerNamespace}
@@ -1669,14 +1270,6 @@ function liveReference(namespaceId, ownerNamespace, factId) {
 // 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;
@@ -2082,8 +1675,8 @@ var HuggingFaceResilience = class {
   async execute(input) {
     const models = [input.model, ...input.fallbackModels ?? []];
     let lastError;
-    for (const [index2, model] of models.entries()) {
-      const fallbackTriggered = index2 > 0;
+    for (const [index, model] of models.entries()) {
+      const fallbackTriggered = index > 0;
       try {
         return await this.executeForModel(model, input, fallbackTriggered);
       } catch (error) {
@@ -2150,8 +1743,7 @@ var HuggingFaceResilience = class {
               retries = error.attemptNumber;
             }
           }
-        ),
-        { throwOnTimeout: true }
+        )
       );
       this.markWarm(model);
       status = fallbackTriggered ? "fallback" : "success";
@@ -2284,7 +1876,7 @@ function readRetryAfterMs(error) {
   return Number.isFinite(retryAfterSeconds) ? retryAfterSeconds * 1e3 : void 0;
 }
 function sleep(ms) {
-  return new Promise((resolve3) => setTimeout(resolve3, ms));
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 
 // src/providers/huggingface.ts
@@ -2389,7 +1981,7 @@ function normalizeEmbeddingResponse(response) {
     return [response];
   }
   if (response.every(
-    (vector2) => Array.isArray(vector2) && vector2.every((value) => typeof value === "number")
+    (vector) => Array.isArray(vector) && vector.every((value) => typeof value === "number")
   )) {
     return response;
   }
@@ -2479,308 +2071,6 @@ 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;
@@ -2793,6 +2083,7 @@ var EmbeddingWorker = class {
   batchSize;
   maxAttempts;
   onDiagnostic;
+  namespaceId;
   state = "idle";
   loopPromise = null;
   wake = null;
@@ -2805,6 +2096,7 @@ var EmbeddingWorker = class {
     this.batchSize = options.batchSize ?? DEFAULT_BATCH_SIZE;
     this.maxAttempts = options.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
     this.onDiagnostic = options.onDiagnostic;
+    this.namespaceId = options.namespaceId;
   }
   getState() {
     return this.state;
@@ -2834,8 +2126,8 @@ var EmbeddingWorker = class {
    * wait out anymore.
    */
   async drain() {
-    await new Promise((resolve3) => {
-      this.idleResolvers.push(resolve3);
+    await new Promise((resolve2) => {
+      this.idleResolvers.push(resolve2);
       this.notify();
     });
   }
@@ -2861,13 +2153,13 @@ var EmbeddingWorker = class {
     while (this.state === "running") {
       let jobs;
       try {
-        jobs = await this.repo.claimPendingEmbeddings(this.batchSize);
+        jobs = await this.repo.claimPendingEmbeddings(this.batchSize, this.namespaceId?.());
       } 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));
+        await new Promise((resolve2) => setTimeout(resolve2, ERROR_BACKOFF_MS));
         continue;
       }
       if (jobs.length === 0) {
@@ -2894,7 +2186,7 @@ var EmbeddingWorker = class {
     if (this.inFlight > 0) return;
     const resolvers = this.idleResolvers;
     this.idleResolvers = [];
-    for (const resolve3 of resolvers) resolve3();
+    for (const resolve2 of resolvers) resolve2();
   }
   async processJob(job) {
     let leaseLost = false;
@@ -2914,14 +2206,14 @@ var EmbeddingWorker = class {
         model: job.embeddingModel
       });
       validateEmbeddingResponse(response, 1);
-      const vector2 = response.vectors[0];
-      if (!vector2 || vector2.length === 0) {
+      const vector = response.vectors[0];
+      if (!vector || vector.length === 0) {
         throw new Error("Provider returned no embedding vector.");
       }
       if (leaseLost || !await this.repo.markEmbeddingReady(
         job.id,
         job.leaseToken,
-        vector2,
+        vector,
         response.model,
         embeddingSpaceKey(embeddingSpace(response))
       ))
@@ -2979,14 +2271,14 @@ var EmbeddingWorker = class {
     });
   }
   sleep(ms) {
-    return new Promise((resolve3) => {
+    return new Promise((resolve2) => {
       const timer = setTimeout(() => {
         this.wake = null;
-        resolve3();
+        resolve2();
       }, ms ?? this.pollIntervalMs);
       this.wake = () => {
         clearTimeout(timer);
-        resolve3();
+        resolve2();
       };
     });
   }
@@ -3017,6 +2309,7 @@ var CodeBuddy = class {
     this.worker = deps.worker ?? new EmbeddingWorker({
       repository: this.repo,
       provider: this.provider,
+      namespaceId: () => this.namespaceId ?? void 0,
       ...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 } : {}
@@ -3160,8 +2453,8 @@ var CodeBuddy = class {
         })
       );
       validateEmbeddingResponse(response, 1);
-      const vector2 = response.vectors[0];
-      return vector2 ? { vector: vector2, space: embeddingSpace(response) } : null;
+      const vector = response.vectors[0];
+      return vector ? { vector, space: embeddingSpace(response) } : null;
     } catch {
       return null;
     }
@@ -3343,9 +2636,10 @@ var CodeBuddy = class {
     };
     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);
+      const file = await this.memoryFileStore?.readFact(id).catch(() => null);
+      if (file?.namespace === this.config.namespace) {
+        await this.memoryFileStore?.deleteFact(id);
+        return { ...result, found: true };
       }
       return result;
     });
@@ -3361,7 +2655,7 @@ var CodeBuddy = class {
    * file is applied independently: malformed or conflicting files are reported
    * in `failures` and never abort healthy imports (nor count as deletions).
    */
-  async reindexMemory() {
+  async reindexMemory(options = {}) {
     const namespaceId = this.requireNamespaceId();
     const store = this.memoryFileStore;
     if (!store) {
@@ -3441,7 +2735,7 @@ var CodeBuddy = class {
         failures: failures.slice(0, MAX_REPORTED_FAILURES)
       };
     });
-    const space = this.provider.space;
+    const space = options.respace === false ? void 0 : this.provider.space;
     const canEmbed = space !== void 0 && await this.provider.embed({ input: "codebuddy" }).then(
       () => true,
       () => false
@@ -3787,8 +3081,8 @@ function decodeFactCursor(cursor) {
   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 };
+  const [createdAt, id] = parsed;
+  return { createdAt: new Date(createdAt), id };
 }
 async function listFactsPage(memory, repository, input) {
   const namespace = await repository.ensureNamespace(memory.config.namespace);
@@ -3824,6 +3118,7 @@ async function inspectNamespace(repository, namespace) {
   };
 }
 async function runDoctor(options = {}) {
+  const migrated = await migrateLegacyNamespace();
   const fileConfig = await readConfigFile();
   const scaffold = await checkProjectScaffold();
   const configPermissions = await checkConfigPermissions();
@@ -3833,6 +3128,7 @@ async function runDoctor(options = {}) {
     expectedDefault: expectedDefaultNamespace,
     configured: fileConfig.namespace ?? null,
     runtime: runtimeNamespace,
+    ...migrated ? { migrated } : {},
     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.`
@@ -3977,17 +3273,12 @@ async function checkModels(provider, skip = false) {
 }
 
 export {
-  isEligibleMemory,
-  lexicalTerms,
   embeddingSpaceKey,
   DefaultPolicy,
   HuggingFaceProvider,
   isLangSmithTracingEnabled,
   createTracer,
   codeBuddyConfigSchema,
-  FACT_CATEGORIES,
-  INCIDENT_SEVERITIES,
-  MemoryFileStore,
   EmbeddingWorker,
   CodeBuddy,
   buildProviderFromConfig,
@@ -4003,4 +3294,4 @@ export {
   inspectNamespace,
   runDoctor
 };
-//# sourceMappingURL=chunk-JDZ3VK26.js.map
+//# sourceMappingURL=chunk-2XDPKFUW.js.map