@askexenow/exe-os 0.9.295 → 0.9.296

package/dist/chunk-VRRAE5JX.js

@@ -0,0 +1,836 @@
+import {
+  extractKeywords,
+  keywordsToString
+} from "./chunk-CHCA3ZM2.js";
+import {
+  blobToVector
+} from "./chunk-OTVEIJUQ.js";
+import {
+  findScopedDuplicate,
+  governMemoryRecord,
+  schedulePostWriteMemoryHygiene
+} from "./chunk-C2SBESBO.js";
+import {
+  orgBus
+} from "./chunk-MP2AFCGL.js";
+import {
+  disposeTurso,
+  ensureSchema,
+  getClient,
+  initTurso
+} from "./chunk-WUKHLCBE.js";
+import {
+  EMBEDDING_DIM
+} from "./chunk-FXU7JOXK.js";
+import {
+  getMasterKey
+} from "./chunk-Z42MXYWW.js";
+import {
+  loadConfig
+} from "./chunk-R36FAN53.js";
+
+// src/lib/store.ts
+var _debugStore = process.env.EXE_DEBUG === "1";
+function logStoreDebug(context, err) {
+  if (_debugStore) {
+    process.stderr.write(
+      `[store] ${context}: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+  }
+}
+function logStoreWarn(context, err) {
+  process.stderr.write(
+    `[store] WARN ${context}: ${err instanceof Error ? err.message : String(err)}
+`
+  );
+}
+var SHARD_CB_MAX_FAILURES = 3;
+var SHARD_CB_COOLDOWN_MS = 5 * 6e4;
+var _shardCircuits = /* @__PURE__ */ new Map();
+function isShardCircuitOpen(project) {
+  const state = _shardCircuits.get(project);
+  if (!state || state.openedAt === null) return false;
+  if (Date.now() - state.openedAt > SHARD_CB_COOLDOWN_MS) {
+    state.openedAt = null;
+    state.failures = 0;
+    return false;
+  }
+  return true;
+}
+function recordShardFailure(project, error) {
+  const state = _shardCircuits.get(project) ?? { failures: 0, openedAt: null, lastError: "" };
+  state.failures++;
+  state.lastError = error;
+  if (state.failures >= SHARD_CB_MAX_FAILURES && state.openedAt === null) {
+    state.openedAt = Date.now();
+    process.stderr.write(
+      `[store] Shard circuit OPEN for "${project}" after ${state.failures} consecutive failures. Will retry in ${SHARD_CB_COOLDOWN_MS / 6e4}min. Last error: ${error}
+`
+    );
+    void import("./orchestration-events-MGCGPTDN.js").then(({ recordOrchestrationEventBestEffort }) => {
+      recordOrchestrationEventBestEffort({
+        eventType: "shard.circuit_open",
+        source: "store.recordShardFailure",
+        severity: "error",
+        projectName: project,
+        payload: { failures: state.failures, lastError: error.slice(0, 200) }
+      });
+    }).catch(() => {
+    });
+  }
+  _shardCircuits.set(project, state);
+}
+function recordShardSuccess(project) {
+  _shardCircuits.delete(project);
+}
+var INIT_MAX_RETRIES = 3;
+var INIT_RETRY_DELAY_MS = 1e3;
+function isBusyError(err) {
+  if (err instanceof Error) {
+    const msg = err.message.toLowerCase();
+    return msg.includes("sqlite_busy") || msg.includes("database is locked");
+  }
+  return false;
+}
+async function retryOnBusy(fn, label) {
+  for (let attempt = 0; attempt <= INIT_MAX_RETRIES; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      if (!isBusyError(err) || attempt === INIT_MAX_RETRIES) throw err;
+      process.stderr.write(
+        `[store] SQLITE_BUSY during ${label}, retry ${attempt + 1}/${INIT_MAX_RETRIES}
+`
+      );
+      await new Promise((r) => setTimeout(r, INIT_RETRY_DELAY_MS * (attempt + 1)));
+    }
+  }
+  throw new Error("unreachable");
+}
+var _pendingRecords = [];
+var _batchSize = 20;
+var _flushIntervalMs = 1e4;
+var _flushTimer = null;
+var _flushing = false;
+var _nextVersion = 1;
+async function initStore(options) {
+  if (_flushTimer !== null) {
+    clearInterval(_flushTimer);
+    _flushTimer = null;
+  }
+  _pendingRecords = [];
+  _flushing = false;
+  _batchSize = options?.batchSize ?? 20;
+  _flushIntervalMs = options?.flushIntervalMs ?? 1e4;
+  let dbPath = options?.dbPath;
+  if (!dbPath) {
+    const config = await loadConfig();
+    dbPath = config.dbPath;
+  }
+  let masterKey = options?.masterKey ?? null;
+  if (!masterKey) {
+    masterKey = await getMasterKey();
+    if (!masterKey) {
+      throw new Error(
+        "No encryption key found. Run /exe-setup to generate one."
+      );
+    }
+  }
+  const hexKey = masterKey.toString("hex");
+  await initTurso({
+    dbPath,
+    encryptionKey: hexKey
+  });
+  await retryOnBusy(() => ensureSchema(), "ensureSchema");
+  try {
+    const { initDaemonClient } = await import("./lib/database.js");
+    await initDaemonClient();
+  } catch (e) {
+    logStoreWarn("catch", e);
+  }
+  if (!options?.lightweight) {
+    try {
+      if (process.env.EXE_DISABLE_SHARDING !== "1") {
+        const { initShardManager } = await import("./shard-manager-P5ZJH4AX.js");
+        initShardManager(hexKey);
+      }
+    } catch (e) {
+      logStoreWarn("catch", e);
+    }
+    const client = getClient();
+    const vResult = await retryOnBusy(
+      () => client.execute("SELECT MAX(version) as max_v FROM memories"),
+      "version-query"
+    );
+    _nextVersion = (Number(vResult.rows[0]?.max_v) || 0) + 1;
+    try {
+      const { loadGlobalProcedures } = await import("./global-procedures-6JCQWU4D.js");
+      await loadGlobalProcedures();
+    } catch (e) {
+      logStoreWarn("catch", e);
+    }
+  }
+}
+function classifyTier(record) {
+  if (record.tool_name === "commit_to_long_term_memory" && (record.importance ?? 0) >= 8) return 1;
+  if (["store_memory", "manual"].includes(record.tool_name ?? "") && (record.importance ?? 0) >= 5) return 2;
+  return 3;
+}
+function inferFilePaths(record) {
+  if (!["Read", "Write", "Edit"].includes(record.tool_name)) return null;
+  const firstLine = record.raw_text.split("\n")[0] ?? "";
+  const match = firstLine.match(/(\/[\w./-]+\.\w+)/);
+  return match ? JSON.stringify([match[1]]) : null;
+}
+function inferCommitHash(record) {
+  if (record.tool_name !== "Bash") return null;
+  const match = record.raw_text.match(/\b([a-f0-9]{7,40})\b/);
+  return match ? match[1] : null;
+}
+function inferLanguageType(record) {
+  const text = record.raw_text;
+  if (!text || text.length < 10) return null;
+  const trimmed = text.trimStart();
+  if (trimmed.startsWith("{") || trimmed.startsWith("[")) return "json";
+  if (/\b(SELECT|INSERT|UPDATE|DELETE|CREATE TABLE|ALTER TABLE)\b/i.test(text)) return "sql";
+  if (/\b(function |const |import |export |class |def |async |=>)\b/.test(text)) return "code";
+  if (trimmed.startsWith("#") || trimmed.startsWith("*")) return "prose";
+  return "mixed";
+}
+function inferDomain(record) {
+  const proj = (record.project_name ?? "").toLowerCase();
+  if (proj.includes("marketing") || proj.includes("content")) return "marketing";
+  if (proj.includes("crm") || proj.includes("customer")) return "customer";
+  return null;
+}
+async function writeMemory(record) {
+  if (record.agent_id) record.agent_id = record.agent_id.toLowerCase();
+  if (record.vector !== null && record.vector.length !== EMBEDDING_DIM) {
+    throw new Error(
+      `Expected ${EMBEDDING_DIM}-dim vector, got ${record.vector.length}`
+    );
+  }
+  const governed = governMemoryRecord(record);
+  if (governed.shouldDrop) return;
+  record = governed.record;
+  const contentHash = governed.contentHash;
+  const memoryType = record.memory_type ?? "raw";
+  if (_pendingRecords.some(
+    (r) => r.content_hash === contentHash && r.agent_id === record.agent_id && r.project_name === record.project_name && (r.memory_type ?? "raw") === memoryType
+  )) {
+    return;
+  }
+  try {
+    const existing = await findScopedDuplicate({
+      contentHash,
+      agentId: record.agent_id,
+      projectName: record.project_name,
+      memoryType
+    });
+    if (existing) return;
+  } catch (e) {
+    logStoreWarn("catch", e);
+  }
+  if (!record.session_scope) {
+    try {
+      const { resolveExeSession } = await import("./lib/tmux-routing.js");
+      record.session_scope = resolveExeSession() ?? null;
+    } catch {
+    }
+  }
+  const dbRow = {
+    id: record.id,
+    agent_id: record.agent_id,
+    agent_role: record.agent_role,
+    session_id: record.session_id,
+    timestamp: record.timestamp,
+    tool_name: record.tool_name,
+    project_name: record.project_name,
+    has_error: record.has_error ? 1 : 0,
+    raw_text: record.raw_text,
+    vector: record.vector,
+    version: 0,
+    // Placeholder — assigned atomically at flush time
+    task_id: record.task_id ?? null,
+    importance: record.importance ?? 5,
+    status: record.status ?? "active",
+    confidence: record.confidence ?? 0.7,
+    last_accessed: record.last_accessed ?? record.timestamp,
+    workspace_id: record.workspace_id ?? null,
+    document_id: record.document_id ?? null,
+    user_id: record.user_id ?? null,
+    char_offset: record.char_offset ?? null,
+    page_number: record.page_number ?? null,
+    source_path: record.source_path ?? null,
+    source_type: record.source_type ?? null,
+    tier: record.tier ?? classifyTier(record),
+    supersedes_id: record.supersedes_id ?? null,
+    valid_from: record.valid_from ?? record.timestamp,
+    invalid_at: record.invalid_at ?? null,
+    draft: record.draft ? 1 : 0,
+    memory_type: memoryType,
+    trajectory: record.trajectory ? JSON.stringify(record.trajectory) : null,
+    content_hash: contentHash,
+    intent: record.intent ?? null,
+    outcome: record.outcome ?? null,
+    domain: record.domain ?? inferDomain(record),
+    referenced_entities: record.referenced_entities ?? null,
+    retrieval_count: record.retrieval_count ?? 0,
+    chain_position: record.chain_position ?? null,
+    review_status: record.review_status ?? null,
+    context_window_pct: record.context_window_pct ?? null,
+    file_paths: record.file_paths ?? inferFilePaths(record),
+    commit_hash: record.commit_hash ?? inferCommitHash(record),
+    duration_ms: record.duration_ms ?? null,
+    token_cost: record.token_cost ?? null,
+    audience: record.audience ?? null,
+    language_type: record.language_type ?? inferLanguageType(record),
+    parent_memory_id: record.parent_memory_id ?? null,
+    procedure_for: record.procedure_for ?? null,
+    session_scope: record.session_scope ?? null,
+    keywords: record.keywords ?? keywordsToString(extractKeywords(record.raw_text)),
+    founder_id: record.founder_id ?? null
+  };
+  try {
+    const { checkMemoryPoisoning } = await import("./memory-poisoning-defense-4YVJYH4G.js");
+    const poisonResult = await checkMemoryPoisoning({
+      memoryId: dbRow.id,
+      vector: Array.isArray(dbRow.vector) ? dbRow.vector : void 0,
+      agentId: dbRow.agent_id,
+      projectName: dbRow.project_name,
+      toolName: dbRow.tool_name,
+      sessionId: dbRow.session_id,
+      importance: dbRow.importance ?? 5
+    });
+    if (poisonResult.quarantined) {
+      dbRow.quarantined = 1;
+      dbRow.quarantine_reason = poisonResult.reason ?? "flagged";
+    }
+  } catch {
+  }
+  _pendingRecords.push(dbRow);
+  orgBus.emit({
+    type: "memory_stored",
+    agentId: record.agent_id,
+    project: record.project_name,
+    timestamp: record.timestamp
+  });
+  const MAX_PENDING = 1e3;
+  if (_pendingRecords.length >= MAX_PENDING) {
+    _pendingRecords.shift();
+    process.stderr.write(`[exe-os] \u26A0 Memory buffer full (${MAX_PENDING}) \u2014 oldest record dropped. This indicates sustained high write volume.
+`);
+  }
+  if (_flushTimer === null) {
+    _flushTimer = setInterval(() => {
+      void flushBatch();
+    }, _flushIntervalMs);
+    if (_flushTimer && typeof _flushTimer === "object" && "unref" in _flushTimer) {
+      _flushTimer.unref();
+    }
+  }
+  if (_pendingRecords.length >= _batchSize) {
+    await flushBatch();
+  }
+}
+async function flushBatch() {
+  if (_flushing || _pendingRecords.length === 0) return 0;
+  _flushing = true;
+  try {
+    const batch = _pendingRecords.slice(0);
+    const client = getClient();
+    const interactiveTx = client.interactiveTransactions !== false;
+    if (interactiveTx) await client.execute("BEGIN IMMEDIATE");
+    const vResult = await client.execute("SELECT COALESCE(MAX(version), 0) as max_v FROM memories");
+    let baseVersion = (Number(vResult.rows[0]?.max_v) || 0) + 1;
+    for (const row of batch) {
+      row.version = baseVersion++;
+    }
+    let _extractKeywords = null;
+    let _keywordsToString = null;
+    try {
+      const mod = await import("./keyword-extractor-UJHFWVZE.js");
+      _extractKeywords = mod.extractKeywords;
+      _keywordsToString = mod.keywordsToString;
+    } catch {
+    }
+    const buildStmt = (row) => {
+      const hasVector = row.vector !== null;
+      const taskId = row.task_id ?? null;
+      const importance = row.importance ?? 5;
+      const status = row.status ?? "active";
+      const confidence = row.confidence ?? 0.7;
+      const lastAccessed = row.last_accessed ?? row.timestamp;
+      const workspaceId = row.workspace_id ?? null;
+      const documentId = row.document_id ?? null;
+      const userId = row.user_id ?? null;
+      const charOffset = row.char_offset ?? null;
+      const pageNumber = row.page_number ?? null;
+      const sourcePath = row.source_path ?? null;
+      const sourceType = row.source_type ?? null;
+      const tier = row.tier ?? 3;
+      const supersedesId = row.supersedes_id ?? null;
+      const validFrom = row.valid_from ?? row.timestamp;
+      const invalidAt = row.invalid_at ?? null;
+      const draft = row.draft ? 1 : 0;
+      const memoryType = row.memory_type ?? "raw";
+      const trajectory = row.trajectory ?? null;
+      const contentHash = row.content_hash ?? null;
+      const keywords = row.keywords ?? (_extractKeywords && _keywordsToString ? _keywordsToString(_extractKeywords(row.raw_text)) : "");
+      const intent = row.intent ?? null;
+      const outcome = row.outcome ?? null;
+      const domain = row.domain ?? null;
+      const referencedEntities = row.referenced_entities ?? null;
+      const retrievalCount = row.retrieval_count ?? 0;
+      const chainPosition = row.chain_position ?? null;
+      const reviewStatus = row.review_status ?? null;
+      const contextWindowPct = row.context_window_pct ?? null;
+      const filePaths = row.file_paths ?? null;
+      const commitHash = row.commit_hash ?? null;
+      const durationMs = row.duration_ms ?? null;
+      const tokenCost = row.token_cost ?? null;
+      const audience = row.audience ?? null;
+      const languageType = row.language_type ?? null;
+      const parentMemoryId = row.parent_memory_id ?? null;
+      const procedureFor = row.procedure_for ?? null;
+      const sessionScope = row.session_scope ?? null;
+      const founderId = row.founder_id ?? null;
+      const cols = `id, agent_id, agent_role, session_id, timestamp,
+               tool_name, project_name,
+               has_error, raw_text, vector, version, task_id, importance, status,
+               confidence, last_accessed,
+               workspace_id, document_id, user_id, char_offset, page_number,
+               source_path, source_type, tier, supersedes_id, valid_from, invalid_at, draft, memory_type, trajectory, content_hash,
+               intent, outcome, domain, referenced_entities, retrieval_count,
+               chain_position, review_status, context_window_pct, file_paths, commit_hash,
+               duration_ms, token_cost, audience, language_type, parent_memory_id, procedure_for, session_scope, keywords, founder_id`;
+      const metaArgs = [
+        intent,
+        outcome,
+        domain,
+        referencedEntities,
+        retrievalCount,
+        chainPosition,
+        reviewStatus,
+        contextWindowPct,
+        filePaths,
+        commitHash,
+        durationMs,
+        tokenCost,
+        audience,
+        languageType,
+        parentMemoryId,
+        procedureFor,
+        sessionScope,
+        keywords,
+        founderId
+      ];
+      const baseArgs = [
+        row.id,
+        row.agent_id,
+        row.agent_role,
+        row.session_id,
+        row.timestamp,
+        row.tool_name,
+        row.project_name,
+        row.has_error,
+        row.raw_text
+      ];
+      const sharedArgs = [
+        row.version,
+        taskId,
+        importance,
+        status,
+        confidence,
+        lastAccessed,
+        workspaceId,
+        documentId,
+        userId,
+        charOffset,
+        pageNumber,
+        sourcePath,
+        sourceType,
+        tier,
+        supersedesId,
+        validFrom,
+        invalidAt,
+        draft,
+        memoryType,
+        trajectory,
+        contentHash
+      ];
+      return {
+        sql: hasVector ? `INSERT OR IGNORE INTO memories (${cols})
+              VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, vector32(?), ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)` : `INSERT OR IGNORE INTO memories (${cols})
+              VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        args: hasVector ? [...baseArgs, vectorToBlob(row.vector), ...sharedArgs, ...metaArgs] : [...baseArgs, ...sharedArgs, ...metaArgs]
+      };
+    };
+    const globalStmts = batch.map(buildStmt);
+    if (interactiveTx) {
+      try {
+        for (const stmt of globalStmts) {
+          await client.execute(stmt);
+        }
+        await client.execute("COMMIT");
+      } catch (txErr) {
+        try {
+          await client.execute("ROLLBACK");
+        } catch {
+        }
+        throw txErr;
+      }
+    } else {
+      await client.batch(globalStmts, "write");
+    }
+    _nextVersion = baseVersion;
+    try {
+      const { insertMemoryCardsForBatch } = await import("./memory-cards-4RVDZIY2.js");
+      await insertMemoryCardsForBatch(batch);
+    } catch (e) {
+      logStoreWarn("catch", e);
+    }
+    try {
+      const { insertOntologyForBatch } = await import("./agentic-ontology-A2YUZK5O.js");
+      await insertOntologyForBatch(batch);
+    } catch (e) {
+      logStoreWarn("catch", e);
+    }
+    try {
+      const { extractGraphForBatch } = await import("./memory-graph-extractor-L6YC7G4M.js");
+      await extractGraphForBatch(batch);
+    } catch (e) {
+      logStoreWarn("catch", e);
+    }
+    schedulePostWriteMemoryHygiene(batch.map((row) => row.id));
+    _pendingRecords.splice(0, batch.length);
+    try {
+      const { isShardingEnabled, getReadyShardClient } = await import("./shard-manager-P5ZJH4AX.js");
+      if (process.env.EXE_DISABLE_SHARDING !== "1" && isShardingEnabled()) {
+        const byProject = /* @__PURE__ */ new Map();
+        let skippedUnknown = 0;
+        for (const row of batch) {
+          const proj = row.project_name?.trim();
+          if (!proj) {
+            skippedUnknown++;
+            continue;
+          }
+          if (!byProject.has(proj)) byProject.set(proj, []);
+          byProject.get(proj).push(row);
+        }
+        if (skippedUnknown > 0) {
+          process.stderr.write(
+            `[store] Shard skip: ${skippedUnknown} record(s) with empty project_name (kept in main DB only)
+`
+          );
+        }
+        for (const [project, rows] of byProject) {
+          if (isShardCircuitOpen(project)) {
+            logStoreDebug("shard-circuit", `Skipping shard write for "${project}" \u2014 circuit open`);
+            continue;
+          }
+          try {
+            const shardClient = await getReadyShardClient(project);
+            const shardStmts = rows.map(buildStmt);
+            await shardClient.batch(shardStmts, "write");
+            recordShardSuccess(project);
+          } catch (err) {
+            const fullError = err instanceof Error ? `${err.name}: ${err.message}${err.stack ? `
+${err.stack.split("\n").slice(1, 3).join("\n")}` : ""}` : String(err);
+            recordShardFailure(project, fullError);
+            process.stderr.write(
+              `[store] Shard write failed for ${project} (${rows.length} records): ${fullError}
+`
+            );
+          }
+        }
+      }
+    } catch (e) {
+      logStoreWarn("catch", e);
+    }
+    return batch.length;
+  } finally {
+    _flushing = false;
+  }
+}
+function buildWikiScopeFilter(options, columnPrefix) {
+  const args = [];
+  let clause = "";
+  if (options?.workspaceId !== void 0) {
+    clause += ` AND ${columnPrefix}workspace_id = ?`;
+    args.push(options.workspaceId);
+  }
+  if (options?.userId === void 0) {
+    clause += ` AND ${columnPrefix}user_id IS NULL`;
+  } else if (options.userId === null) {
+    clause += ` AND ${columnPrefix}user_id IS NULL`;
+  } else {
+    clause += ` AND (${columnPrefix}user_id = ? OR ${columnPrefix}user_id IS NULL)`;
+    args.push(options.userId);
+  }
+  return { clause, args };
+}
+function buildRawVisibilityFilter(options, columnPrefix) {
+  if (options?.includeRaw === false) {
+    return {
+      clause: ` AND COALESCE(${columnPrefix}memory_type, 'raw') != 'raw'`,
+      args: []
+    };
+  }
+  return { clause: "", args: [] };
+}
+async function searchMemories(queryVector, agentId, options) {
+  let client;
+  try {
+    const { isShardingEnabled, shardExists, getReadyShardClient } = await import("./shard-manager-P5ZJH4AX.js");
+    if (isShardingEnabled() && options?.projectName && shardExists(options.projectName)) {
+      client = await getReadyShardClient(options.projectName);
+    } else {
+      client = getClient();
+    }
+  } catch (e) {
+    logStoreDebug("shard routing fallback", e);
+    client = getClient();
+  }
+  const limit = options?.limit ?? 10;
+  const activeEmbeddingModel = (await loadConfig()).modelFile;
+  let hasEmbeddingModelCol = false;
+  try {
+    const info = await client.execute("PRAGMA table_info(memories)");
+    hasEmbeddingModelCol = info.rows.some((r) => r.name === "embedding_model");
+  } catch (e) {
+    logStoreDebug("embedding_model column check failed", e);
+  }
+  const statusFilter = options?.includeArchived ? "" : `
+               AND COALESCE(status, 'active') = 'active'`;
+  const draftFilter = options?.includeDrafts ? "" : `
+               AND (draft = 0 OR draft IS NULL)`;
+  let sql = `SELECT id, agent_id, agent_role, session_id, timestamp,
+                    tool_name, project_name,
+                    has_error, raw_text, vector, importance, status,
+                    confidence, last_accessed,
+                    workspace_id, document_id, user_id,
+                    char_offset, page_number,
+                    source_path, source_type, strength
+             FROM memories
+             WHERE (agent_id = ? OR agent_id = 'wiki')
+               AND vector IS NOT NULL${statusFilter}${draftFilter}
+               AND COALESCE(confidence, 0.7) >= 0.3`;
+  const args = [agentId];
+  if (hasEmbeddingModelCol && typeof activeEmbeddingModel === "string" && activeEmbeddingModel.length > 0) {
+    sql += `
+               AND (embedding_model = ? OR embedding_model IS NULL)`;
+    args.push(activeEmbeddingModel);
+  }
+  try {
+    const { founderScopeFilter } = await import("./founder-context-QAAWZEZM.js");
+    const founderFilter = founderScopeFilter(options?.founderId);
+    sql += founderFilter.sql;
+    args.push(...founderFilter.args.filter((a) => a !== null));
+  } catch {
+  }
+  if (options?.asOf) {
+    sql += ` AND (valid_from IS NULL OR valid_from <= ?) AND (invalid_at IS NULL OR invalid_at > ?)`;
+    args.push(options.asOf, options.asOf);
+  } else {
+    sql += ` AND invalid_at IS NULL`;
+  }
+  const scope = buildWikiScopeFilter(options, "");
+  sql += scope.clause;
+  args.push(...scope.args);
+  const rawVisibility = buildRawVisibilityFilter(options, "");
+  sql += rawVisibility.clause;
+  args.push(...rawVisibility.args);
+  if (options?.projectName) {
+    sql += ` AND project_name = ?`;
+    args.push(options.projectName);
+  }
+  if (options?.sessionScope) {
+    sql += ` AND (session_scope = ? OR session_scope IS NULL)`;
+    args.push(options.sessionScope);
+  }
+  if (options?.toolName) {
+    sql += ` AND tool_name = ?`;
+    args.push(options.toolName);
+  }
+  if (options?.hasError !== void 0) {
+    sql += ` AND has_error = ?`;
+    args.push(options.hasError ? 1 : 0);
+  }
+  if (options?.since) {
+    sql += ` AND timestamp >= ?`;
+    args.push(options.since);
+  }
+  if (options?.memoryTypes && options.memoryTypes.length > 0) {
+    const uniqueTypes = [...new Set(options.memoryTypes)];
+    sql += ` AND memory_type IN (${uniqueTypes.map(() => "?").join(",")})`;
+    args.push(...uniqueTypes);
+  } else if (options?.memoryType) {
+    sql += ` AND memory_type = ?`;
+    args.push(options.memoryType);
+  }
+  sql += ` ORDER BY vector_distance_cos(vector, vector32(?))`;
+  args.push(vectorToBlob(queryVector));
+  sql += ` LIMIT ?`;
+  args.push(limit);
+  const result = await client.execute({ sql, args });
+  return result.rows.map((row) => ({
+    id: row.id,
+    agent_id: row.agent_id,
+    agent_role: row.agent_role,
+    session_id: row.session_id,
+    timestamp: row.timestamp,
+    tool_name: row.tool_name,
+    project_name: row.project_name,
+    has_error: row.has_error === 1,
+    raw_text: row.raw_text,
+    vector: row.vector == null ? [] : Array.isArray(row.vector) ? row.vector : blobToVector(row.vector),
+    importance: row.importance ?? 5,
+    status: row.status ?? "active",
+    confidence: row.confidence ?? 0.7,
+    last_accessed: row.last_accessed ?? row.timestamp,
+    workspace_id: row.workspace_id ?? null,
+    document_id: row.document_id ?? null,
+    user_id: row.user_id ?? null,
+    char_offset: row.char_offset ?? null,
+    page_number: row.page_number ?? null,
+    source_path: row.source_path ?? null,
+    source_type: row.source_type ?? null,
+    strength: row.strength ?? 1
+  }));
+}
+async function attachDocumentMetadata(records) {
+  const docIds = [
+    ...new Set(
+      records.map((r) => r.document_id).filter((id) => typeof id === "string" && id.length > 0)
+    )
+  ];
+  if (docIds.length === 0) return records;
+  try {
+    const client = getClient();
+    const placeholders = docIds.map(() => "?").join(",");
+    const result = await client.execute({
+      sql: `SELECT id, filename, mime, source_type, uploaded_at
+            FROM documents
+            WHERE id IN (${placeholders})`,
+      args: docIds
+    });
+    const byId = /* @__PURE__ */ new Map();
+    for (const row of result.rows) {
+      const id = row.id;
+      byId.set(id, {
+        document_id: id,
+        filename: row.filename,
+        mime: row.mime ?? null,
+        source_type: row.source_type ?? null,
+        uploaded_at: row.uploaded_at
+      });
+    }
+    for (const record of records) {
+      if (!record.document_id) continue;
+      record.document_metadata = byId.get(record.document_id) ?? null;
+    }
+  } catch (e) {
+    logStoreWarn("catch", e);
+  }
+  return records;
+}
+async function flushTier3(agentId, options) {
+  const client = getClient();
+  const maxAge = options?.maxAgeHours ?? 72;
+  const cutoff = new Date(Date.now() - maxAge * 36e5).toISOString();
+  if (options?.dryRun) {
+    const result2 = await client.execute({
+      sql: `SELECT COUNT(*) as cnt FROM memories
+            WHERE agent_id = ? AND tier = 3 AND status = 'active' AND timestamp < ?`,
+      args: [agentId, cutoff]
+    });
+    return { archived: Number(result2.rows[0]?.cnt ?? 0) };
+  }
+  const result = await client.execute({
+    sql: `UPDATE memories SET status = 'archived'
+          WHERE agent_id = ? AND tier = 3 AND status = 'active' AND timestamp < ?`,
+    args: [agentId, cutoff]
+  });
+  return { archived: result.rowsAffected };
+}
+async function disposeStore() {
+  if (_flushTimer !== null) {
+    clearInterval(_flushTimer);
+    _flushTimer = null;
+  }
+  if (_pendingRecords.length > 0) {
+    await flushBatch();
+  }
+  await disposeTurso();
+  _pendingRecords = [];
+  _nextVersion = 1;
+}
+function vectorToSqlLiteral(vector) {
+  const f32 = vector instanceof Float32Array ? vector : new Float32Array(vector);
+  return JSON.stringify(Array.from(f32));
+}
+var vectorToBlob = vectorToSqlLiteral;
+async function updateMemoryStatus(id, status) {
+  const client = getClient();
+  await client.execute({
+    sql: `UPDATE memories SET status = ? WHERE id = ?`,
+    args: [status, id]
+  });
+}
+async function reserveVersions(count) {
+  const client = getClient();
+  await client.execute("BEGIN IMMEDIATE");
+  try {
+    const vResult = await client.execute("SELECT COALESCE(MAX(version), 0) as max_v FROM memories");
+    let baseVersion = (Number(vResult.rows[0]?.max_v) || 0) + 1;
+    if (_nextVersion > baseVersion) {
+      baseVersion = _nextVersion;
+    }
+    const reserved = [];
+    for (let i = 0; i < count; i++) {
+      reserved.push(baseVersion + i);
+    }
+    _nextVersion = baseVersion + count;
+    await client.execute("COMMIT");
+    return reserved;
+  } catch (err) {
+    try {
+      await client.execute("ROLLBACK");
+    } catch {
+    }
+    throw err;
+  }
+}
+async function getMemoryCardinality(agentId) {
+  try {
+    const client = getClient();
+    const result = await client.execute({
+      sql: `SELECT COUNT(*) as cnt FROM memories WHERE agent_id = ? AND COALESCE(status, 'active') = 'active'`,
+      args: [agentId]
+    });
+    return Number(result.rows[0]?.cnt) || 0;
+  } catch (e) {
+    logStoreWarn("getMemoryCardinality", e);
+    return 0;
+  }
+}
+
+export {
+  initStore,
+  classifyTier,
+  writeMemory,
+  flushBatch,
+  buildWikiScopeFilter,
+  buildRawVisibilityFilter,
+  searchMemories,
+  attachDocumentMetadata,
+  flushTier3,
+  disposeStore,
+  vectorToSqlLiteral,
+  vectorToBlob,
+  updateMemoryStatus,
+  reserveVersions,
+  getMemoryCardinality
+};