kongbrain 0.5.0 → 0.5.2

package/dist/chunk-XSIONAGJ.js

@@ -0,0 +1,1364 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/log.ts
+var LEVELS, currentLevel, log;
+var init_log = __esm({
+  "src/log.ts"() {
+    "use strict";
+    LEVELS = { error: 0, warn: 1, info: 2, debug: 3 };
+    currentLevel = process.env.KONGBRAIN_LOG_LEVEL ?? "warn";
+    log = {
+      error: (...args) => {
+        if (LEVELS[currentLevel] >= LEVELS.error) console.error("[kongbrain]", ...args);
+      },
+      warn: (...args) => {
+        if (LEVELS[currentLevel] >= LEVELS.warn) console.warn("[kongbrain]", ...args);
+      },
+      info: (...args) => {
+        if (LEVELS[currentLevel] >= LEVELS.info) console.info("[kongbrain]", ...args);
+      },
+      debug: (...args) => {
+        if (LEVELS[currentLevel] >= LEVELS.debug) console.debug("[kongbrain]", ...args);
+      }
+    };
+  }
+});
+
+// src/errors.ts
+function swallow(context, err) {
+  if (!DEBUG) return;
+  const msg = err instanceof Error ? err.message : String(err ?? "unknown");
+  log.debug(`[swallow] ${context}: ${msg}`);
+}
+var DEBUG;
+var init_errors = __esm({
+  "src/errors.ts"() {
+    "use strict";
+    init_log();
+    DEBUG = process.env.KONGBRAIN_DEBUG === "1";
+    swallow.warn = function swallowWarn(context, err) {
+      const msg = err instanceof Error ? err.message : String(err ?? "unknown");
+      log.warn(`${context}: ${msg}`);
+    };
+    swallow.error = function swallowError(context, err) {
+      const msg = err instanceof Error ? err.message : String(err ?? "unknown");
+      const stack = err instanceof Error ? `
+${err.stack}` : "";
+      log.error(`${context}: ${msg}${stack}`);
+    };
+  }
+});
+
+// src/surreal.ts
+init_errors();
+init_log();
+import { Surreal } from "surrealdb";
+
+// src/schema-loader.ts
+import { readFileSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var DEFAULT_EMBEDDING_DIMENSIONS = 1024;
+var DIMENSION_PLACEHOLDER = "__KONGBRAIN_EMBEDDING_DIMENSIONS__";
+function normalizeDimensions(value) {
+  return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : DEFAULT_EMBEDDING_DIMENSIONS;
+}
+function loadSchema(options = {}) {
+  const primary = join(__dirname, "schema.surql");
+  let schema;
+  try {
+    schema = readFileSync(primary, "utf-8");
+  } catch {
+    schema = readFileSync(join(__dirname, "..", "src", "schema.surql"), "utf-8");
+  }
+  return schema.replaceAll(
+    DIMENSION_PLACEHOLDER,
+    String(normalizeDimensions(options.embeddingDimensions))
+  );
+}
+
+// src/surreal.ts
+var RECORD_ID_RE = /^[a-zA-Z_][a-zA-Z0-9_]*:[a-zA-Z0-9_]+$/;
+function assertRecordId(id) {
+  if (!RECORD_ID_RE.test(id)) {
+    throw new Error(`Invalid record ID format: ${id.slice(0, 40)}`);
+  }
+}
+var VALID_EDGES = /* @__PURE__ */ new Set([
+  // Semantic edges
+  "responds_to",
+  "tool_result_of",
+  "summarizes",
+  "mentions",
+  "related_to",
+  "narrower",
+  "broader",
+  "about_concept",
+  "reflects_on",
+  // Skill edges
+  "skill_from_task",
+  "skill_uses_concept",
+  // Structural pillar edges
+  "owns",
+  "performed",
+  "task_part_of",
+  "session_task",
+  "produced",
+  "derived_from",
+  "relevant_to",
+  "used_in",
+  "artifact_mentions",
+  // Causal edges
+  "caused_by",
+  "supports",
+  "contradicts",
+  "describes",
+  // Evolution edges
+  "supersedes",
+  // Session edges
+  "part_of"
+]);
+function assertValidEdge(edge) {
+  if (!VALID_EDGES.has(edge)) throw new Error(`Invalid edge name: ${edge}`);
+}
+function patchOrderByFields(sql) {
+  const s = sql.trim();
+  if (!/^\s*SELECT\b/i.test(s) || !/\bORDER\s+BY\b/i.test(s)) return sql;
+  if (/^\s*SELECT\s+\*/i.test(s)) return sql;
+  const selectMatch = s.match(/^\s*SELECT\s+([\s\S]+?)\s+FROM\b/i);
+  if (!selectMatch) return sql;
+  const selectClause = selectMatch[1];
+  const orderMatch = s.match(
+    /\bORDER\s+BY\s+([\s\S]+?)(?=\s+LIMIT\b|\s+GROUP\b|\s+HAVING\b|$)/i
+  );
+  if (!orderMatch) return sql;
+  const orderFields = orderMatch[1].split(",").map((f) => f.trim().replace(/\s+(ASC|DESC)\s*$/i, "").trim()).filter(Boolean);
+  const selectedFields = selectClause.split(",").map((f) => f.trim().split(/\s+AS\s+/i)[0].trim()).map((f) => f.split(".").pop()).filter(Boolean).map((f) => f.toLowerCase());
+  const missing = orderFields.filter(
+    (f) => !selectedFields.includes(f.split(".").pop().toLowerCase())
+  );
+  if (missing.length === 0) return sql;
+  return sql.replace(
+    /(\bSELECT\s+)([\s\S]+?)(\s+FROM\b)/i,
+    (_, pre, fields, post) => `${pre}${fields}, ${missing.join(", ")}${post}`
+  );
+}
+var SurrealStore = class _SurrealStore {
+  constructor(config, options = {}) {
+    this.reconnecting = null;
+    this.shutdownFlag = false;
+    this.initialized = false;
+    /**
+     * The embedding provider tag used to stamp writes and filter searches.
+     * Set once at startup via setActiveProvider() after the EmbeddingService
+     * is constructed. Falls back to "local-bge-m3" so existing single-provider
+     * deployments keep working if the wire-up step is ever skipped.
+     */
+    this.activeProvider = "local-bge-m3";
+    // ── Reflection session lookup ─────────────────────────────────────────
+    this._reflectionSessions = null;
+    this.config = config;
+    this.schemaOptions = options;
+    this.db = new Surreal();
+  }
+  /** Set the embedding provider id used to stamp writes and filter searches. */
+  setActiveProvider(providerId) {
+    this.activeProvider = providerId;
+  }
+  /** Get the active provider id (for callers writing records via direct CREATE). */
+  getActiveProvider() {
+    return this.activeProvider;
+  }
+  /** Connect and run schema. Returns true if a new connection was made, false if already initialized. */
+  async initialize() {
+    if (this.initialized) return false;
+    await this.db.connect(this.config.url, {
+      namespace: this.config.ns,
+      database: this.config.db,
+      authentication: { username: this.config.user, password: this.config.pass }
+    });
+    await this.runSchema();
+    this.initialized = true;
+    return true;
+  }
+  markShutdown() {
+    this.shutdownFlag = true;
+  }
+  async ensureConnected() {
+    if (this.shutdownFlag) return;
+    if (this.db.isConnected) return;
+    if (this.reconnecting) return this.reconnecting;
+    this.reconnecting = (async () => {
+      const MAX_ATTEMPTS = 3;
+      const BACKOFF_MS = [500, 1500, 4e3];
+      for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+        try {
+          log.warn(
+            `SurrealDB disconnected \u2014 reconnecting (attempt ${attempt}/${MAX_ATTEMPTS})...`
+          );
+          this.db = new Surreal();
+          const CONNECT_TIMEOUT_MS = 5e3;
+          await Promise.race([
+            this.db.connect(this.config.url, {
+              namespace: this.config.ns,
+              database: this.config.db,
+              authentication: { username: this.config.user, password: this.config.pass }
+            }),
+            new Promise(
+              (_, reject) => setTimeout(
+                () => reject(new Error(`SurrealDB connect timed out after ${CONNECT_TIMEOUT_MS}ms`)),
+                CONNECT_TIMEOUT_MS
+              )
+            )
+          ]);
+          log.warn("SurrealDB reconnected successfully.");
+          return;
+        } catch (e) {
+          if (attempt < MAX_ATTEMPTS) {
+            await new Promise((r) => setTimeout(r, BACKOFF_MS[attempt - 1]));
+          } else {
+            log.error(`SurrealDB reconnection failed after ${MAX_ATTEMPTS} attempts.`);
+            throw new Error("SurrealDB reconnection failed");
+          }
+        }
+      }
+    })().finally(() => {
+      this.reconnecting = null;
+    });
+    return this.reconnecting;
+  }
+  async runSchema() {
+    const schema = loadSchema({
+      embeddingDimensions: this.schemaOptions.embeddingDimensions
+    });
+    await this.db.query(schema);
+  }
+  getConnection() {
+    return this.db;
+  }
+  isConnected() {
+    return this.db?.isConnected ?? false;
+  }
+  getInfo() {
+    return {
+      url: this.config.url,
+      ns: this.config.ns,
+      db: this.config.db,
+      connected: this.db?.isConnected ?? false
+    };
+  }
+  async ping() {
+    try {
+      await this.ensureConnected();
+      await this.db.query("RETURN 'ok'");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async close() {
+    try {
+      this.markShutdown();
+      await this.db?.close();
+    } catch (e) {
+      swallow("surreal:close", e);
+    }
+  }
+  /** Returns true if an error is a connection-level failure worth retrying. */
+  isConnectionError(e) {
+    const msg = String(e?.message ?? e);
+    return msg.includes("must be connected") || msg.includes("ConnectionUnavailable");
+  }
+  /** Run a query function with one retry on connection errors. */
+  async withRetry(fn) {
+    try {
+      return await fn();
+    } catch (e) {
+      if (!this.isConnectionError(e)) throw e;
+      this.initialized = false;
+      try {
+        await this.db?.close();
+      } catch {
+      }
+      this.db = new Surreal();
+      await this.db.connect(this.config.url, {
+        namespace: this.config.ns,
+        database: this.config.db,
+        authentication: { username: this.config.user, password: this.config.pass }
+      });
+      return await fn();
+    }
+  }
+  // ── Query helpers ──────────────────────────────────────────────────────
+  async queryFirst(sql, bindings) {
+    await this.ensureConnected();
+    return this.withRetry(async () => {
+      const ns = this.config.ns;
+      const dbName = this.config.db;
+      const fullSql = `USE NS ${ns} DB ${dbName}; ${patchOrderByFields(sql)}`;
+      const result = await this.db.query(fullSql, bindings);
+      const rows = Array.isArray(result) ? result[result.length - 1] : result;
+      return (Array.isArray(rows) ? rows : []).filter(Boolean);
+    });
+  }
+  async queryMulti(sql, bindings) {
+    await this.ensureConnected();
+    return this.withRetry(async () => {
+      const ns = this.config.ns;
+      const dbName = this.config.db;
+      const fullSql = `USE NS ${ns} DB ${dbName}; ${patchOrderByFields(sql)}`;
+      const raw = await this.db.query(fullSql, bindings);
+      const flat = raw.flat();
+      return flat[flat.length - 1];
+    });
+  }
+  async queryExec(sql, bindings) {
+    await this.ensureConnected();
+    return this.withRetry(async () => {
+      const ns = this.config.ns;
+      const dbName = this.config.db;
+      const fullSql = `USE NS ${ns} DB ${dbName}; ${patchOrderByFields(sql)}`;
+      await this.db.query(fullSql, bindings);
+    });
+  }
+  /**
+   * Execute N SQL statements in a single SurrealDB round-trip.
+   * Returns one result array per statement; bindings are shared across all statements.
+   */
+  async queryBatch(statements, bindings) {
+    if (statements.length === 0) return [];
+    await this.ensureConnected();
+    return this.withRetry(async () => {
+      const ns = this.config.ns;
+      const dbName = this.config.db;
+      const joined = statements.map((s) => patchOrderByFields(s)).join(";\n");
+      const fullSql = `USE NS ${ns} DB ${dbName};
+${joined}`;
+      const raw = await this.db.query(fullSql, bindings);
+      return raw.slice(1).map((r) => (Array.isArray(r) ? r : []).filter(Boolean));
+    });
+  }
+  async safeQuery(sql, bindings) {
+    try {
+      return await this.queryFirst(sql, bindings);
+    } catch (e) {
+      swallow.warn("surreal:safeQuery", e);
+      return [];
+    }
+  }
+  // ── Vector search ──────────────────────────────────────────────────────
+  /** Multi-table cosine similarity search across turns, concepts, memories, artifacts, monologues, and identity chunks. Returns merged results sorted by score. */
+  async vectorSearch(vec, sessionId, limits = {}, withEmbeddings = false) {
+    const lim = {
+      turn: limits.turn ?? 20,
+      identity: limits.identity ?? 10,
+      concept: limits.concept ?? 15,
+      memory: limits.memory ?? 15,
+      artifact: limits.artifact ?? 10,
+      monologue: limits.monologue ?? 8
+    };
+    const sessionTurnLim = Math.ceil(lim.turn / 2);
+    const crossTurnLim = lim.turn - sessionTurnLim;
+    const emb = withEmbeddings ? ", embedding" : "";
+    const stmts = [
+      `SELECT id, text, role, timestamp, 0 AS accessCount, 'turn' AS table,
+              vector::similarity::cosine(embedding, $vec) AS score${emb}
+       FROM turn WHERE embedding != NONE AND array::len(embedding) > 0
+         AND embedding_provider = $provider
+         AND session_id = $sid ORDER BY score DESC LIMIT ${sessionTurnLim}`,
+      `SELECT id, text, role, timestamp, 0 AS accessCount, 'turn' AS table,
+              vector::similarity::cosine(embedding, $vec) AS score${emb}
+       FROM turn WHERE embedding != NONE AND array::len(embedding) > 0
+         AND embedding_provider = $provider
+         AND session_id != $sid ORDER BY score DESC LIMIT ${crossTurnLim}`,
+      `SELECT id, content AS text, stability AS importance, access_count AS accessCount,
+              created_at AS timestamp, 'concept' AS table,
+              vector::similarity::cosine(embedding, $vec) AS score${emb}
+       FROM concept WHERE embedding != NONE AND array::len(embedding) > 0
+         AND embedding_provider = $provider
+       ORDER BY score DESC LIMIT ${lim.concept}`,
+      `SELECT id, text, importance, access_count AS accessCount,
+              created_at AS timestamp, session_id AS sessionId, 'memory' AS table,
+              vector::similarity::cosine(embedding, $vec) AS score${emb}
+       FROM memory WHERE embedding != NONE AND array::len(embedding) > 0
+         AND embedding_provider = $provider
+         AND (status = 'active' OR status IS NONE) ORDER BY score DESC LIMIT ${lim.memory}`,
+      `SELECT id, description AS text, 0 AS accessCount,
+              created_at AS timestamp, 'artifact' AS table,
+              vector::similarity::cosine(embedding, $vec) AS score${emb}
+       FROM artifact WHERE embedding != NONE AND array::len(embedding) > 0
+         AND embedding_provider = $provider
+       ORDER BY score DESC LIMIT ${lim.artifact}`,
+      `SELECT id, content AS text, category AS source, 0.5 AS importance, 0 AS accessCount,
+              timestamp, 'monologue' AS table,
+              vector::similarity::cosine(embedding, $vec) AS score${emb}
+       FROM monologue WHERE embedding != NONE AND array::len(embedding) > 0
+         AND embedding_provider = $provider
+       ORDER BY score DESC LIMIT ${lim.monologue}`,
+      `SELECT id, text, importance, 0 AS accessCount,
+              'identity_chunk' AS table,
+              vector::similarity::cosine(embedding, $vec) AS score${emb}
+       FROM identity_chunk WHERE embedding != NONE AND array::len(embedding) > 0
+         AND embedding_provider = $provider
+       ORDER BY score DESC LIMIT ${lim.identity}`
+    ];
+    let batchResults;
+    try {
+      batchResults = await this.queryBatch(stmts, { vec, sid: sessionId, provider: this.activeProvider });
+    } catch (e) {
+      swallow.warn("surreal:vectorSearch:batch", e);
+      return [];
+    }
+    const [sessionTurns = [], crossTurns = [], concepts = [], memories = [], artifacts = [], monologues = [], identityChunks = []] = batchResults;
+    return [
+      ...sessionTurns,
+      ...crossTurns,
+      ...concepts,
+      ...memories,
+      ...artifacts,
+      ...monologues,
+      ...identityChunks
+    ];
+  }
+  // ── Turn operations ────────────────────────────────────────────────────
+  async upsertTurn(turn) {
+    const { embedding, ...rest } = turn;
+    const record = embedding?.length ? { ...rest, embedding, embedding_provider: this.activeProvider } : rest;
+    const rows = await this.queryFirst(
+      `CREATE turn CONTENT $turn RETURN id`,
+      { turn: record }
+    );
+    return String(rows[0]?.id ?? "");
+  }
+  async getSessionTurns(sessionId, limit = 50) {
+    return this.queryFirst(
+      `SELECT role, text, timestamp FROM turn WHERE session_id = $sid ORDER BY timestamp ASC LIMIT $lim`,
+      { sid: sessionId, lim: limit }
+    );
+  }
+  async getSessionTurnsRich(sessionId, limit = 20) {
+    return this.queryFirst(
+      `SELECT role, text, tool_name, timestamp FROM turn WHERE session_id = $sid ORDER BY timestamp ASC LIMIT $lim`,
+      { sid: sessionId, lim: limit }
+    );
+  }
+  // ── Relation helpers ───────────────────────────────────────────────────
+  async relate(fromId, edge, toId) {
+    assertRecordId(fromId);
+    assertRecordId(toId);
+    const safeName = edge.replace(/[^a-zA-Z0-9_]/g, "");
+    await this.queryExec(`RELATE ${fromId}->${safeName}->${toId}`);
+  }
+  // ── 5-Pillar entity operations ─────────────────────────────────────────
+  async ensureAgent(name, model) {
+    const rows = await this.queryFirst(
+      `SELECT id FROM agent WHERE name = $name LIMIT 1`,
+      { name }
+    );
+    if (rows.length > 0) return String(rows[0].id);
+    const created = await this.queryFirst(
+      `CREATE agent CONTENT { name: $name, model: $model } RETURN id`,
+      { name, ...model != null ? { model } : {} }
+    );
+    return String(created[0]?.id ?? "");
+  }
+  async ensureProject(name) {
+    const rows = await this.queryFirst(
+      `SELECT id FROM project WHERE name = $name LIMIT 1`,
+      { name }
+    );
+    if (rows.length > 0) return String(rows[0].id);
+    const created = await this.queryFirst(
+      `CREATE project CONTENT { name: $name } RETURN id`,
+      { name }
+    );
+    return String(created[0]?.id ?? "");
+  }
+  async createTask(description) {
+    const rows = await this.queryFirst(
+      `CREATE task CONTENT { description: $desc, status: "in_progress" } RETURN id`,
+      { desc: description }
+    );
+    return String(rows[0]?.id ?? "");
+  }
+  async createSession(agentId = "default") {
+    const rows = await this.queryFirst(
+      `CREATE session CONTENT { agent_id: $agent_id } RETURN id`,
+      { agent_id: agentId }
+    );
+    return String(rows[0]?.id ?? "");
+  }
+  async updateSessionStats(sessionId, inputTokens, outputTokens) {
+    assertRecordId(sessionId);
+    await this.queryExec(
+      `UPDATE ${sessionId} SET
+        turn_count += 1,
+        total_input_tokens += $input,
+        total_output_tokens += $output,
+        last_active = time::now()`,
+      { input: inputTokens, output: outputTokens }
+    );
+  }
+  async endSession(sessionId, summary) {
+    assertRecordId(sessionId);
+    if (summary) {
+      await this.queryExec(
+        `UPDATE ${sessionId} SET ended_at = time::now(), summary = $summary`,
+        { summary }
+      );
+    } else {
+      await this.queryExec(`UPDATE ${sessionId} SET ended_at = time::now()`);
+    }
+  }
+  async markSessionActive(sessionId) {
+    assertRecordId(sessionId);
+    await this.queryExec(
+      `UPDATE ${sessionId} SET cleanup_completed = false, last_active = time::now()`
+    );
+  }
+  async markSessionEnded(sessionId) {
+    assertRecordId(sessionId);
+    await this.queryExec(
+      `UPDATE ${sessionId} SET ended_at = time::now(), cleanup_completed = true`
+    );
+  }
+  async getOrphanedSessions(limit = 3) {
+    return this.queryFirst(
+      `SELECT id, started_at FROM session
+       WHERE cleanup_completed != true
+         AND started_at < time::now() - 2m
+       ORDER BY started_at DESC LIMIT $lim`,
+      { lim: limit }
+    );
+  }
+  async linkSessionToTask(sessionId, taskId) {
+    assertRecordId(sessionId);
+    assertRecordId(taskId);
+    await this.queryExec(
+      `RELATE ${sessionId}->session_task->${taskId}`
+    );
+  }
+  async linkTaskToProject(taskId, projectId) {
+    assertRecordId(taskId);
+    assertRecordId(projectId);
+    await this.queryExec(
+      `RELATE ${taskId}->task_part_of->${projectId}`
+    );
+  }
+  async linkAgentToTask(agentId, taskId) {
+    assertRecordId(agentId);
+    assertRecordId(taskId);
+    await this.queryExec(
+      `RELATE ${agentId}->performed->${taskId}`
+    );
+  }
+  async linkAgentToProject(agentId, projectId) {
+    assertRecordId(agentId);
+    assertRecordId(projectId);
+    await this.queryExec(
+      `RELATE ${agentId}->owns->${projectId}`
+    );
+  }
+  // ── Graph traversal ────────────────────────────────────────────────────
+  /**
+   * BFS expansion from seed nodes along typed edges, with batched per-hop queries.
+   * Each edge query is LIMIT 3 (EDGE_NEIGHBOR_LIMIT) to bound fan-out per node.
+   */
+  /**
+   * Tag-boosted concept retrieval: extract keywords from query text,
+   * find concepts tagged with matching terms, score by cosine similarity.
+   * Returns concepts that pure vector search might miss due to embedding mismatch.
+   */
+  async tagBoostedConcepts(queryText, queryVec, limit = 10) {
+    const stopwords = /* @__PURE__ */ new Set(["the", "a", "an", "is", "are", "was", "were", "be", "been", "being", "have", "has", "had", "do", "does", "did", "will", "would", "could", "should", "may", "might", "can", "shall", "to", "of", "in", "for", "on", "with", "at", "by", "from", "as", "into", "about", "between", "through", "during", "it", "its", "this", "that", "these", "those", "i", "you", "we", "they", "my", "your", "our", "their", "what", "which", "who", "how", "when", "where", "why", "not", "no", "and", "or", "but", "if", "so", "any", "all", "some", "more", "just", "also", "than", "very", "too", "much", "many"]);
+    const words = queryText.toLowerCase().replace(/[^a-z0-9\s-]/g, "").split(/\s+/).filter((w) => w.length > 2 && !stopwords.has(w));
+    if (words.length === 0) return [];
+    const tagConditions = words.slice(0, 8).map((w) => `tags CONTAINS '${w.replace(/'/g, "")}'`).join(" OR ");
+    try {
+      const rows = await this.queryFirst(
+        `SELECT id, content AS text, stability AS importance, access_count AS accessCount,
+                created_at AS timestamp, 'concept' AS table,
+                vector::similarity::cosine(embedding, $vec) AS score
+         FROM concept
+         WHERE embedding != NONE AND array::len(embedding) > 0
+           AND embedding_provider = $provider
+           AND (${tagConditions})
+         ORDER BY score DESC
+         LIMIT $limit`,
+        { vec: queryVec, limit, provider: this.activeProvider }
+      );
+      return rows;
+    } catch (e) {
+      swallow.warn("surreal:tagBoostedConcepts", e);
+      return [];
+    }
+  }
+  async graphExpand(nodeIds, queryVec, hops = 1) {
+    if (nodeIds.length === 0) return [];
+    const MAX_FRONTIER_SEEDS = 5;
+    const MAX_FRONTIER_PER_HOP = 3;
+    const EDGE_NEIGHBOR_LIMIT = 3;
+    const forwardEdges = [
+      // Semantic edges
+      "responds_to",
+      "tool_result_of",
+      "summarizes",
+      "mentions",
+      "related_to",
+      "narrower",
+      "broader",
+      "about_concept",
+      "reflects_on",
+      "skill_from_task",
+      "skill_uses_concept",
+      // Structural pillar edges (Agent→Project→Task→Artifact→Concept)
+      "owns",
+      "performed",
+      "task_part_of",
+      "session_task",
+      "produced",
+      "derived_from",
+      "relevant_to",
+      "used_in",
+      "artifact_mentions"
+    ];
+    const reverseEdges = [
+      "reflects_on",
+      "skill_from_task",
+      // Reverse pillar traversal (find what produced an artifact, what task a concept came from)
+      "produced",
+      "derived_from",
+      "performed",
+      "owns"
+    ];
+    const scoreExpr = ", IF embedding != NONE AND array::len(embedding) > 0 AND embedding_provider = $provider THEN vector::similarity::cosine(embedding, $vec) ELSE 0 END AS score";
+    const bindings = { vec: queryVec, provider: this.activeProvider };
+    const selectFields = `SELECT id, text, content, description, importance, stability,
+                  access_count AS accessCount, created_at AS timestamp,
+                  meta::tb(id) AS table${scoreExpr}`;
+    const seen = new Set(nodeIds);
+    const allNeighbors = [];
+    let frontier = nodeIds.slice(0, MAX_FRONTIER_SEEDS).filter((id) => RECORD_ID_RE.test(id));
+    for (let hop = 0; hop < hops && frontier.length > 0; hop++) {
+      const stmts = [];
+      for (const id of frontier) {
+        for (const edge of forwardEdges) {
+          assertValidEdge(edge);
+          stmts.push(`${selectFields} FROM ${id}->${edge}->? LIMIT ${EDGE_NEIGHBOR_LIMIT}`);
+        }
+        for (const edge of reverseEdges) {
+          assertValidEdge(edge);
+          stmts.push(`${selectFields} FROM ${id}<-${edge}<-? LIMIT ${EDGE_NEIGHBOR_LIMIT}`);
+        }
+      }
+      let queryResults;
+      try {
+        queryResults = await this.queryBatch(stmts, bindings);
+      } catch (e) {
+        swallow.warn("surreal:graphExpand:batch", e);
+        break;
+      }
+      const nextFrontier = [];
+      for (const rows of queryResults) {
+        for (const row of rows) {
+          const nodeId = String(row.id);
+          if (seen.has(nodeId)) continue;
+          seen.add(nodeId);
+          const text = row.text ?? row.content ?? row.description ?? null;
+          if (text) {
+            const score = row.score ?? 0;
+            allNeighbors.push({
+              text,
+              importance: row.importance ?? row.stability,
+              accessCount: row.accessCount,
+              timestamp: row.timestamp,
+              table: String(row.table ?? "unknown"),
+              id: nodeId,
+              score
+            });
+            if (RECORD_ID_RE.test(nodeId)) {
+              nextFrontier.push({ id: nodeId, score });
+            }
+          }
+        }
+      }
+      frontier = nextFrontier.sort((a, b) => b.score - a.score).slice(0, MAX_FRONTIER_PER_HOP).map((n) => n.id);
+    }
+    return allNeighbors;
+  }
+  async bumpAccessCounts(ids) {
+    const validated = ids.filter((id) => {
+      try {
+        assertRecordId(id);
+        return true;
+      } catch {
+        return false;
+      }
+    });
+    if (validated.length === 0) return;
+    try {
+      const stmts = validated.map(
+        (id) => `UPDATE ${id} SET access_count += 1, last_accessed = time::now()`
+      );
+      await this.queryBatch(stmts);
+    } catch (e) {
+      swallow.warn("surreal:bumpAccessCounts", e);
+    }
+  }
+  // ── Concept / Memory / Artifact CRUD ───────────────────────────────────
+  async upsertConcept(content, embedding, source) {
+    if (!content?.trim()) return "";
+    content = content.trim();
+    const rows = await this.queryFirst(
+      `SELECT id FROM concept WHERE string::lowercase(content) = string::lowercase($content) LIMIT 1`,
+      { content }
+    );
+    if (rows.length > 0) {
+      const id = String(rows[0].id);
+      if (embedding?.length) {
+        await this.queryExec(
+          `UPDATE ${id} SET access_count += 1, last_accessed = time::now(),
+            embedding = IF embedding IS NONE OR array::len(embedding) = 0 THEN $emb ELSE embedding END,
+            embedding_provider = IF embedding IS NONE OR array::len(embedding) = 0 THEN $provider ELSE embedding_provider END`,
+          { emb: embedding, provider: this.activeProvider }
+        );
+      } else {
+        await this.queryExec(
+          `UPDATE ${id} SET access_count += 1, last_accessed = time::now()`
+        );
+      }
+      return id;
+    }
+    const emb = embedding?.length ? embedding : void 0;
+    const record = { content, source: source ?? void 0 };
+    if (emb) {
+      record.embedding = emb;
+      record.embedding_provider = this.activeProvider;
+    }
+    const created = await this.queryFirst(
+      `CREATE concept CONTENT $record RETURN id`,
+      { record }
+    );
+    return String(created[0]?.id ?? "");
+  }
+  async createArtifact(path, type, description, embedding) {
+    const record = { path, type, description };
+    if (embedding?.length) {
+      record.embedding = embedding;
+      record.embedding_provider = this.activeProvider;
+    }
+    const rows = await this.queryFirst(
+      `CREATE artifact CONTENT $record RETURN id`,
+      { record }
+    );
+    return String(rows[0]?.id ?? "");
+  }
+  async createMemory(text, embedding, importance, category, sessionId) {
+    const source = category ?? "general";
+    if (embedding?.length) {
+      const dupes = await this.queryFirst(
+        `SELECT id, importance,
+                vector::similarity::cosine(embedding, $vec) AS score
+         FROM memory
+         WHERE embedding != NONE AND array::len(embedding) > 0
+           AND embedding_provider = $provider
+           AND category = $cat
+         ORDER BY score DESC
+         LIMIT 1`,
+        { vec: embedding, cat: source, provider: this.activeProvider }
+      );
+      if (dupes.length > 0 && dupes[0].score > 0.92) {
+        const existing = dupes[0];
+        const newImp = Math.max(existing.importance ?? 0, importance);
+        await this.queryExec(
+          `UPDATE ${String(existing.id)} SET access_count += 1, importance = $imp, last_accessed = time::now()`,
+          { imp: newImp }
+        );
+        return String(existing.id);
+      }
+    }
+    const record = { text, importance, category: source, source };
+    if (embedding?.length) {
+      record.embedding = embedding;
+      record.embedding_provider = this.activeProvider;
+    }
+    if (sessionId) record.session_id = sessionId;
+    const rows = await this.queryFirst(
+      `CREATE memory CONTENT $record RETURN id`,
+      { record }
+    );
+    return String(rows[0]?.id ?? "");
+  }
+  async createMonologue(sessionId, category, content, embedding) {
+    const record = { session_id: sessionId, category, content };
+    if (embedding?.length) {
+      record.embedding = embedding;
+      record.embedding_provider = this.activeProvider;
+    }
+    const rows = await this.queryFirst(
+      `CREATE monologue CONTENT $record RETURN id`,
+      { record }
+    );
+    return String(rows[0]?.id ?? "");
+  }
+  // ── Core Memory (Tier 0/1) ─────────────────────────────────────────────
+  async getAllCoreMemory(tier) {
+    try {
+      if (tier != null) {
+        return await this.queryFirst(
+          `SELECT * FROM core_memory WHERE active = true AND tier = $tier ORDER BY priority DESC`,
+          { tier }
+        );
+      }
+      return await this.queryFirst(
+        `SELECT * FROM core_memory WHERE active = true ORDER BY tier ASC, priority DESC`
+      );
+    } catch (e) {
+      swallow.warn("surreal:getAllCoreMemory", e);
+      return [];
+    }
+  }
+  async createCoreMemory(text, category, priority, tier, sessionId) {
+    const record = { text, category, priority, tier, active: true };
+    if (sessionId) record.session_id = sessionId;
+    const rows = await this.queryFirst(
+      `CREATE core_memory CONTENT $record RETURN id`,
+      { record }
+    );
+    const id = String(rows[0]?.id ?? "");
+    if (!id) throw new Error("createCoreMemory: CREATE returned no ID");
+    return id;
+  }
+  async updateCoreMemory(id, fields) {
+    assertRecordId(id);
+    const ALLOWED_FIELDS = /* @__PURE__ */ new Set(["text", "category", "priority", "tier", "active"]);
+    const sets = [];
+    const bindings = {};
+    for (const [key, val] of Object.entries(fields)) {
+      if (val !== void 0 && ALLOWED_FIELDS.has(key)) {
+        sets.push(`${key} = $${key}`);
+        bindings[key] = val;
+      }
+    }
+    if (sets.length === 0) return false;
+    sets.push("updated_at = time::now()");
+    const rows = await this.queryFirst(
+      `UPDATE ${id} SET ${sets.join(", ")} RETURN id`,
+      bindings
+    );
+    return rows.length > 0;
+  }
+  async deleteCoreMemory(id) {
+    assertRecordId(id);
+    await this.queryExec(
+      `UPDATE ${id} SET active = false, updated_at = time::now()`
+    );
+  }
+  async deactivateSessionMemories(sessionId) {
+    try {
+      await this.queryExec(
+        `UPDATE core_memory SET active = false, updated_at = time::now() WHERE session_id = $sid AND tier = 1`,
+        { sid: sessionId }
+      );
+    } catch (e) {
+      swallow.warn("surreal:deactivateSessionMemories", e);
+    }
+  }
+  // ── Wakeup & lifecycle queries ─────────────────────────────────────────
+  async getLatestHandoff() {
+    try {
+      const rows = await this.queryFirst(
+        `SELECT text, created_at FROM memory WHERE category = "handoff" ORDER BY created_at DESC LIMIT 1`
+      );
+      return rows[0] ?? null;
+    } catch (e) {
+      swallow.warn("surreal:getLatestHandoff", e);
+      return null;
+    }
+  }
+  async countResolvedSinceHandoff(handoffCreatedAt) {
+    try {
+      const rows = await this.queryFirst(
+        `SELECT count() AS count FROM memory WHERE status = 'resolved' AND resolved_at > $ts GROUP ALL`,
+        { ts: handoffCreatedAt }
+      );
+      return rows[0]?.count ?? 0;
+    } catch (e) {
+      swallow.warn("surreal:countResolvedSinceHandoff", e);
+      return 0;
+    }
+  }
+  async getAllIdentityChunks() {
+    try {
+      return await this.queryFirst(
+        `SELECT text, chunk_index FROM identity_chunk ORDER BY chunk_index ASC`
+      );
+    } catch (e) {
+      swallow.warn("surreal:getAllIdentityChunks", e);
+      return [];
+    }
+  }
+  async getRecentMonologues(limit = 5) {
+    try {
+      return await this.queryFirst(
+        `SELECT category, content, timestamp FROM monologue ORDER BY timestamp DESC LIMIT $lim`,
+        { lim: limit }
+      );
+    } catch (e) {
+      swallow.warn("surreal:getRecentMonologues", e);
+      return [];
+    }
+  }
+  async getPreviousSessionTurns(currentSessionId, limit = 10) {
+    try {
+      let prevSessionQuery;
+      const bindings = { lim: limit };
+      if (currentSessionId) {
+        prevSessionQuery = `SELECT id, started_at FROM session WHERE id != $current ORDER BY started_at DESC LIMIT 1`;
+        bindings.current = currentSessionId;
+      } else {
+        prevSessionQuery = `SELECT id, started_at FROM session ORDER BY started_at DESC LIMIT 1`;
+      }
+      const sessionRows = await this.queryFirst(prevSessionQuery, bindings);
+      if (sessionRows.length === 0) return [];
+      const prevSessionId = String(sessionRows[0].id);
+      const turns = await this.queryFirst(
+        `SELECT role, text, tool_name, timestamp FROM turn
+         WHERE id IN (SELECT VALUE in FROM part_of WHERE out = $sid)
+           AND text != NONE AND text != ""
+         ORDER BY timestamp DESC LIMIT $lim`,
+        { sid: prevSessionId, lim: limit }
+      );
+      return turns.reverse();
+    } catch (e) {
+      swallow.warn("surreal:getPreviousSessionTurns", e);
+      return [];
+    }
+  }
+  async getUnresolvedMemories(limit = 5) {
+    try {
+      return await this.queryFirst(
+        `SELECT id, text,
+                math::max([importance - math::min([math::floor(duration::days(time::now() - created_at) / 7), 3]), 0]) AS importance,
+                category
+         FROM memory
+         WHERE (status IS NONE OR status != 'resolved')
+           AND category NOT IN ['handoff', 'monologue', 'reflection', 'compaction', 'consolidation']
+           AND importance >= 6
+         ORDER BY importance DESC
+         LIMIT $lim`,
+        { lim: limit }
+      );
+    } catch (e) {
+      swallow.warn("surreal:getUnresolvedMemories", e);
+      return [];
+    }
+  }
+  async getRecentFailedCausal(limit = 3) {
+    try {
+      return await this.queryFirst(
+        `SELECT description, chain_type, created_at FROM causal_chain WHERE success = false ORDER BY created_at DESC LIMIT $lim`,
+        { lim: limit }
+      );
+    } catch (e) {
+      swallow.warn("surreal:getRecentFailedCausal", e);
+      return [];
+    }
+  }
+  async resolveMemory(memoryId) {
+    try {
+      assertRecordId(memoryId);
+      await this.queryFirst(
+        `UPDATE ${memoryId} SET status = 'resolved', resolved_at = time::now()`
+      );
+      return true;
+    } catch (e) {
+      swallow.warn("surreal:resolveMemory", e);
+      return false;
+    }
+  }
+  // ── Utility cache ──────────────────────────────────────────────────────
+  async updateUtilityCache(memoryId, utilization) {
+    try {
+      await this.queryExec(
+        `UPSERT memory_utility_cache SET
+          memory_id = $mid,
+          retrieval_count += 1,
+          avg_utilization = IF retrieval_count > 1
+            THEN (avg_utilization * (retrieval_count - 1) + $util) / retrieval_count
+            ELSE $util
+          END,
+          last_updated = time::now()
+         WHERE memory_id = $mid`,
+        { mid: memoryId, util: utilization }
+      );
+    } catch (e) {
+      swallow.warn("surreal:updateUtilityCache", e);
+    }
+  }
+  async getUtilityFromCache(ids) {
+    const result = /* @__PURE__ */ new Map();
+    if (ids.length === 0) return result;
+    try {
+      const rows = await this.queryFirst(
+        `SELECT memory_id, avg_utilization FROM memory_utility_cache WHERE memory_id IN $ids`,
+        { ids }
+      );
+      for (const row of rows) {
+        if (row.avg_utilization != null) result.set(String(row.memory_id), row.avg_utilization);
+      }
+    } catch (e) {
+      swallow.warn("surreal:getUtilityFromCache", e);
+    }
+    return result;
+  }
+  async getUtilityCacheEntries(ids) {
+    const result = /* @__PURE__ */ new Map();
+    if (ids.length === 0) return result;
+    try {
+      const rows = await this.queryFirst(
+        `SELECT memory_id, avg_utilization, retrieval_count FROM memory_utility_cache WHERE memory_id IN $ids`,
+        { ids }
+      );
+      for (const row of rows) {
+        if (row.avg_utilization != null) {
+          result.set(String(row.memory_id), {
+            avg_utilization: row.avg_utilization,
+            retrieval_count: row.retrieval_count ?? 0
+          });
+        }
+      }
+    } catch (e) {
+      swallow.warn("surreal:getUtilityCacheEntries", e);
+    }
+    return result;
+  }
+  // ── Maintenance operations ─────────────────────────────────────────────
+  async runMemoryMaintenance() {
+    try {
+      await this.queryExec(`
+        UPDATE memory SET importance = math::max([importance * 0.95, 2.0]) WHERE importance > 2.0;
+        UPDATE memory SET importance = math::max([importance, 3 + ((
+          SELECT VALUE avg_utilization FROM memory_utility_cache WHERE memory_id = string::concat(meta::tb(id), ":", meta::id(id)) LIMIT 1
+        )[0] ?? 0) * 4]) WHERE importance < 7;
+      `);
+    } catch (e) {
+      swallow("surreal:runMemoryMaintenance", e);
+    }
+  }
+  async garbageCollectMemories() {
+    try {
+      const countRows = await this.queryFirst(
+        `SELECT count() AS count FROM memory GROUP ALL`
+      );
+      const count = countRows[0]?.count ?? 0;
+      if (count <= 200) return 0;
+      const pruned = await this.db.query(
+        `LET $stale = (
+          SELECT id FROM memory
+          WHERE created_at < time::now() - 14d
+            AND importance <= 2.0
+            AND (access_count = 0 OR access_count IS NONE)
+            AND string::concat("memory:", id) NOT IN (
+              SELECT VALUE memory_id FROM (
+                SELECT memory_id FROM retrieval_outcome
+                WHERE utilization > 0.2
+                GROUP BY memory_id
+              )
+            )
+          LIMIT 50
+        );
+        FOR $m IN $stale { DELETE $m.id; };
+        RETURN array::len($stale);`
+      );
+      return Number(pruned ?? 0);
+    } catch (e) {
+      swallow.warn("surreal:garbageCollectMemories", e);
+      return 0;
+    }
+  }
+  async archiveOldTurns() {
+    try {
+      const countRows = await this.queryFirst(
+        `SELECT count() AS count FROM turn GROUP ALL`
+      );
+      const count = countRows[0]?.count ?? 0;
+      if (count <= 2e3) return 0;
+      const archived = await this.queryMulti(
+        `LET $stale = (SELECT id FROM turn WHERE timestamp < time::now() - 7d AND id NOT IN (SELECT VALUE memory_id FROM retrieval_outcome WHERE memory_table = 'turn'));
+         FOR $t IN $stale {
+           INSERT INTO turn_archive (SELECT * FROM ONLY $t.id);
+           DELETE $t.id;
+         };
+         RETURN array::len($stale);`
+      );
+      return Number(archived ?? 0);
+    } catch (e) {
+      swallow.warn("surreal:archiveOldTurns", e);
+      return 0;
+    }
+  }
+  async consolidateMemories(embedFn) {
+    try {
+      const countRows = await this.queryFirst(
+        `SELECT count() AS count FROM memory GROUP ALL`
+      );
+      const count = countRows[0]?.count ?? 0;
+      if (count <= 50) return 0;
+      let merged = 0;
+      const seen = /* @__PURE__ */ new Set();
+      const embMemories = await this.queryFirst(
+        `SELECT id, text, importance, category, access_count, embedding, created_at
+         FROM memory
+         WHERE embedding != NONE AND array::len(embedding) > 0
+           AND embedding_provider = $provider
+         ORDER BY created_at ASC
+         LIMIT 50`,
+        { provider: this.activeProvider }
+      );
+      for (const mem of embMemories) {
+        if (seen.has(String(mem.id))) continue;
+        const dupes = await this.queryFirst(
+          `SELECT id, importance, access_count,
+                  vector::similarity::cosine(embedding, $vec) AS score
+           FROM memory
+           WHERE id != $mid
+             AND category = $cat
+             AND embedding != NONE AND array::len(embedding) > 0
+             AND embedding_provider = $provider
+           ORDER BY score DESC
+           LIMIT 3`,
+          { vec: mem.embedding, mid: mem.id, cat: mem.category, provider: this.activeProvider }
+        );
+        for (const dupe of dupes) {
+          if (dupe.score < 0.88) break;
+          if (seen.has(String(dupe.id))) continue;
+          const keepMem = mem.importance > dupe.importance || mem.importance === dupe.importance && (mem.access_count ?? 0) >= (dupe.access_count ?? 0);
+          const [keep, drop] = keepMem ? [mem.id, dupe.id] : [dupe.id, mem.id];
+          assertRecordId(String(keep));
+          assertRecordId(String(drop));
+          await this.queryExec(
+            `UPDATE ${String(keep)} SET access_count += 1, importance = math::max([importance, $imp])`,
+            { imp: dupe.importance }
+          );
+          await this.queryExec(`DELETE ${String(drop)}`);
+          seen.add(String(drop));
+          merged++;
+        }
+      }
+      const unembedded = await this.queryFirst(
+        `SELECT id, text, importance, category, access_count
+         FROM memory
+         WHERE embedding IS NONE OR array::len(embedding) = 0
+         LIMIT 20`
+      );
+      for (const mem of unembedded) {
+        if (seen.has(String(mem.id))) continue;
+        try {
+          const emb = await embedFn(mem.text);
+          if (!emb) continue;
+          await this.queryExec(
+            `UPDATE ${String(mem.id)} SET embedding = $emb, embedding_provider = $provider`,
+            { emb, provider: this.activeProvider }
+          );
+          const dupes = await this.queryFirst(
+            `SELECT id, importance, access_count,
+                    vector::similarity::cosine(embedding, $vec) AS score
+             FROM memory
+             WHERE id != $mid
+               AND category = $cat
+               AND embedding != NONE AND array::len(embedding) > 0
+               AND embedding_provider = $provider
+             ORDER BY score DESC
+             LIMIT 3`,
+            { vec: emb, mid: mem.id, cat: mem.category, provider: this.activeProvider }
+          );
+          for (const dupe of dupes) {
+            if (dupe.score < 0.88) break;
+            if (seen.has(String(dupe.id))) continue;
+            const keepMem = mem.importance > dupe.importance || mem.importance === dupe.importance && (mem.access_count ?? 0) >= (dupe.access_count ?? 0);
+            const [keep, drop] = keepMem ? [mem.id, dupe.id] : [dupe.id, mem.id];
+            assertRecordId(String(keep));
+            assertRecordId(String(drop));
+            await this.queryExec(
+              `UPDATE ${String(keep)} SET access_count += 1, importance = math::max([importance, $imp])`,
+              { imp: dupe.importance }
+            );
+            await this.queryExec(`DELETE ${String(drop)}`);
+            seen.add(String(drop));
+            merged++;
+          }
+        } catch (e) {
+          swallow.warn("surreal:consolidate-backfill", e);
+        }
+      }
+      return merged;
+    } catch (e) {
+      swallow.warn("surreal:consolidateMemories", e);
+      return 0;
+    }
+  }
+  // ── Retrieval session memory ───────────────────────────────────────────
+  async getSessionRetrievedMemories(sessionId) {
+    try {
+      const rows = await this.queryFirst(
+        `SELECT memory_id FROM retrieval_outcome WHERE session_id = $sid AND memory_table = 'memory' GROUP BY memory_id`,
+        { sid: sessionId }
+      );
+      if (rows.length === 0) return [];
+      const ids = rows.map((r) => r.memory_id).filter(Boolean);
+      if (ids.length === 0) return [];
+      const validated = ids.filter((id) => {
+        try {
+          assertRecordId(String(id));
+          return true;
+        } catch {
+          return false;
+        }
+      });
+      if (validated.length === 0) return [];
+      const idList = validated.join(", ");
+      return this.queryFirst(
+        `SELECT id, text FROM memory WHERE id IN [${idList}] AND (status = 'active' OR status IS NONE)`
+      );
+    } catch (e) {
+      swallow.warn("surreal:getSessionRetrievedMemories", e);
+      return [];
+    }
+  }
+  // ── Fibonacci resurfacing ──────────────────────────────────────────────
+  async markSurfaceable(memoryId) {
+    await this.queryExec(
+      `UPDATE $id SET surfaceable = true, fib_index = 0, surface_count = 0, next_surface_at = time::now() + 1d`,
+      { id: memoryId }
+    );
+  }
+  async getDueMemories(limit = 5) {
+    return await this.queryFirst(
+      `SELECT id, text, importance, fib_index, surface_count, created_at
+         FROM memory
+         WHERE surfaceable = true
+           AND next_surface_at <= time::now()
+           AND status = 'active'
+         ORDER BY importance DESC
+         LIMIT $lim`,
+      { lim: limit }
+    ) ?? [];
+  }
+  // ── Compaction checkpoints ─────────────────────────────────────────────
+  async createCompactionCheckpoint(sessionId, rangeStart, rangeEnd) {
+    const rows = await this.queryFirst(
+      `CREATE compaction_checkpoint CONTENT $data RETURN id`,
+      {
+        data: {
+          session_id: sessionId,
+          msg_range_start: rangeStart,
+          msg_range_end: rangeEnd,
+          status: "pending"
+        }
+      }
+    );
+    return String(rows[0]?.id ?? "");
+  }
+  async completeCompactionCheckpoint(checkpointId, memoryId) {
+    assertRecordId(checkpointId);
+    await this.queryExec(
+      `UPDATE ${checkpointId} SET status = "complete", memory_id = $mid`,
+      { mid: memoryId }
+    );
+  }
+  async getPendingCheckpoints(sessionId) {
+    return this.queryFirst(
+      `SELECT id, msg_range_start, msg_range_end FROM compaction_checkpoint WHERE session_id = $sid AND (status = "pending" OR status = "failed")`,
+      { sid: sessionId }
+    );
+  }
+  // ── Availability check ────────────────────────────────────────────────
+  isAvailable() {
+    try {
+      return this.db?.isConnected ?? false;
+    } catch {
+      return false;
+    }
+  }
+  clearReflectionCache() {
+    this._reflectionSessions = null;
+  }
+  async getReflectionSessionIds() {
+    if (this._reflectionSessions) return this._reflectionSessions;
+    try {
+      const rows = await this.queryFirst(
+        `SELECT session_id FROM reflection GROUP BY session_id`
+      );
+      this._reflectionSessions = new Set(rows.map((r) => r.session_id).filter(Boolean));
+    } catch (e) {
+      swallow.warn("surreal:getReflectionSessionIds", e);
+      this._reflectionSessions = /* @__PURE__ */ new Set();
+    }
+    return this._reflectionSessions;
+  }
+  static {
+    // ── Fibonacci resurfacing: advance ────────────────────────────────────
+    this.FIB_DAYS = [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89];
+  }
+  async advanceSurfaceFade(memoryId) {
+    const current = await this.queryFirst(
+      `SELECT fib_index FROM $id`,
+      { id: memoryId }
+    );
+    const idx = current?.[0]?.fib_index ?? 0;
+    const nextIdx = Math.min(idx + 1, _SurrealStore.FIB_DAYS.length - 1);
+    const days = nextIdx < _SurrealStore.FIB_DAYS.length ? _SurrealStore.FIB_DAYS[nextIdx] : _SurrealStore.FIB_DAYS[_SurrealStore.FIB_DAYS.length - 1];
+    await this.queryExec(
+      `UPDATE $id SET fib_index = $nextIdx, surface_count += 1, last_surfaced = time::now(), next_surface_at = time::now() + type::duration($dur)`,
+      { id: memoryId, nextIdx, dur: `${days}d` }
+    );
+  }
+  async resolveSurfaceMemory(memoryId, outcome) {
+    await this.queryExec(
+      `UPDATE $id SET surfaceable = false, last_engaged = time::now(), surface_outcome = $outcome`,
+      { id: memoryId, outcome }
+    );
+  }
+  // ── Dispose ───────────────────────────────────────────────────────────
+  async dispose() {
+    try {
+      await this.close();
+    } catch (e) {
+      swallow("surreal:dispose", e);
+    }
+  }
+};
+
+export {
+  __esm,
+  __export,
+  __toCommonJS,
+  log,
+  init_log,
+  swallow,
+  init_errors,
+  loadSchema,
+  assertRecordId,
+  SurrealStore
+};