remem-mcp 0.5.17

package/dist/chunk-34TEZ5U4.js

@@ -0,0 +1,1676 @@
+import {
+  __esm,
+  __export,
+  generateId,
+  init_esm_shims
+} from "./chunk-RITPZHIB.js";
+
+// src/embedding/local.ts
+var local_exports = {};
+__export(local_exports, {
+  LocalEmbedder: () => LocalEmbedder
+});
+import { pipeline } from "@huggingface/transformers";
+var LocalEmbedder;
+var init_local = __esm({
+  "src/embedding/local.ts"() {
+    "use strict";
+    init_esm_shims();
+    LocalEmbedder = class {
+      dimension = 384;
+      model = "Xenova/all-MiniLM-L6-v2";
+      extractor = null;
+      initPromise = null;
+      /** Initialize the model. This runs once. Subsequent calls return immediately. */
+      async init() {
+        if (this.extractor) return;
+        if (this.initPromise) {
+          await this.initPromise;
+          return;
+        }
+        this.initPromise = (async () => {
+          this.extractor = await pipeline("feature-extraction", this.model);
+        })();
+        await this.initPromise;
+      }
+      async embed(text) {
+        await this.init();
+        if (!this.extractor) throw new Error("Embedder failed to initialize");
+        const output = await this.extractor(text, { pooling: "mean", normalize: true });
+        return Array.from(output.data);
+      }
+    };
+  }
+});
+
+// src/sdk.ts
+init_esm_shims();
+init_local();
+import { createHash as createHash3 } from "crypto";
+import { homedir } from "os";
+import { join as join3 } from "path";
+
+// src/security/redactor.ts
+init_esm_shims();
+var SECRET_PATTERNS = [
+  // OpenAI API key
+  /sk-[a-zA-Z0-9]{20,}/g,
+  // Anthropic API key
+  /sk-ant-[a-zA-Z0-9-]+/g,
+  // GitHub personal access token
+  /ghp_[a-zA-Z0-9]{36}/g,
+  // GitHub OAuth token
+  /gho_[a-zA-Z0-9]{36}/g,
+  // GitHub fine-grained token
+  /github_pat_[a-zA-Z0-9_]{82}/g,
+  // Slack token
+  /xox[baprs]-[a-zA-Z0-9-]+/g,
+  // AWS access key ID
+  /AKIA[0-9A-Z]{16}/g,
+  // AWS secret access key (40 chars, base64-ish)
+  /(?<![A-Za-z0-9+/])[A-Za-z0-9+/]{40}(?![A-Za-z0-9+/])/g,
+  // PEM private key block
+  /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g,
+  // Google API key
+  /AIza[0-9A-Za-z\-_]{35}/g,
+  // Generic bearer token (require 20+ char token to avoid redacting "Bearer with JWT")
+  /Bearer\s+[a-zA-Z0-9\-._~+/]{20,}=*/g
+];
+var MIN_LENGTH = 40;
+var ENTROPY_THRESHOLD = 4.5;
+function shannonEntropy(str) {
+  const freq = /* @__PURE__ */ new Map();
+  for (const ch of str) {
+    freq.set(ch, (freq.get(ch) ?? 0) + 1);
+  }
+  let entropy = 0;
+  const len = str.length;
+  for (const count of freq.values()) {
+    const p = count / len;
+    entropy -= p * Math.log2(p);
+  }
+  return entropy;
+}
+function findHighEntropyStrings(text) {
+  const results = [];
+  const regex = /[a-zA-Z0-9+/=]{40,}/g;
+  let match;
+  match = regex.exec(text);
+  while (match !== null) {
+    const str = match[0];
+    if (str.length >= MIN_LENGTH) {
+      const entropy = shannonEntropy(str);
+      if (entropy >= ENTROPY_THRESHOLD) {
+        results.push(str);
+      }
+    }
+    match = regex.exec(text);
+  }
+  return results;
+}
+function redact(text) {
+  let result = text;
+  let redacted = false;
+  for (const pattern of SECRET_PATTERNS) {
+    const before = result;
+    result = result.replace(pattern, "[REDACTED]");
+    if (result !== before) redacted = true;
+  }
+  const highEntropy = findHighEntropyStrings(result);
+  for (const str of highEntropy) {
+    result = result.replace(str, "[REDACTED]");
+    redacted = true;
+  }
+  return { text: result, redacted };
+}
+
+// src/storage/sqlite.ts
+init_esm_shims();
+import { createHash } from "crypto";
+import { copyFileSync, existsSync, mkdirSync, readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import Database from "better-sqlite3";
+import * as sqliteVec from "sqlite-vec";
+
+// src/utils/rrf.ts
+init_esm_shims();
+var RRF_K = 40;
+var VEC_WEIGHT = 2;
+function rrfMerge(bm25Results, vecResults, limit) {
+  const scores = /* @__PURE__ */ new Map();
+  const sortedBm25 = [...bm25Results].sort((a, b) => a.score - b.score);
+  sortedBm25.forEach((r, i) => {
+    const rank = i + 1;
+    const rrfScore = 1 / (RRF_K + rank);
+    scores.set(r.id, (scores.get(r.id) ?? 0) + rrfScore);
+  });
+  const sortedVec = [...vecResults].sort((a, b) => a.score - b.score);
+  sortedVec.forEach((r, i) => {
+    const rank = i + 1;
+    const rrfScore = 1 / (RRF_K + rank) * VEC_WEIGHT;
+    scores.set(r.id, (scores.get(r.id) ?? 0) + rrfScore);
+  });
+  return [...scores.entries()].map(([id, score]) => ({ id, score })).sort((a, b) => b.score - a.score).slice(0, limit);
+}
+
+// src/storage/sqlite.ts
+var __dirname2 = dirname(fileURLToPath(import.meta.url));
+var CURRENT_SCHEMA_VERSION = 6;
+var SQLiteBackend = class {
+  db;
+  /** Get the underlying database instance (for CodeGraph/Wiki operations). */
+  getDatabase() {
+    return this.db;
+  }
+  constructor(dbPath) {
+    const dir = dirname(dbPath);
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    let readonly = false;
+    try {
+      this.db = new Database(dbPath);
+      this.db.pragma("journal_mode = WAL");
+    } catch {
+      readonly = true;
+      this.db = new Database(dbPath, { readonly: true });
+    }
+    try {
+      this.db.pragma("busy_timeout = 5000");
+    } catch {
+    }
+    if (!readonly) {
+      this.db.pragma("synchronous = NORMAL");
+      this.db.pragma("foreign_keys = OFF");
+    }
+    sqliteVec.load(this.db);
+    if (!readonly) {
+      try {
+        this.detectAndMigrate(dbPath);
+      } catch {
+      }
+    }
+  }
+  /**
+   * Detect the database state and run the correct migration path.
+   */
+  detectAndMigrate(dbPath) {
+    const hasVersionTable = this.db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='schema_version'").get();
+    if (!hasVersionTable) {
+      const tables = this.db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'").all();
+      if (tables.length === 0) {
+        this.runSchema();
+        this.writeSchemaVersion(CURRENT_SCHEMA_VERSION);
+      } else {
+        this.backupDatabase(dbPath);
+        this.migrateV1ToV2();
+        this.migrateV2ToV3();
+        this.migrateV3ToV4();
+        this.migrateV4ToV5();
+        this.migrateV5ToV6();
+        this.runSchema();
+        this.writeSchemaVersion(CURRENT_SCHEMA_VERSION);
+      }
+      return;
+    }
+    const row = this.db.prepare("SELECT MAX(version) as version FROM schema_version").get();
+    const currentVersion = row?.version ?? 0;
+    if (currentVersion < 1) {
+      this.backupDatabase(dbPath);
+      this.runSchema();
+      this.writeSchemaVersion(1);
+    }
+    if (currentVersion < 2) {
+      this.backupDatabase(dbPath);
+      this.migrateV1ToV2();
+      this.writeSchemaVersion(2);
+    }
+    if (currentVersion < 3) {
+      this.backupDatabase(dbPath);
+      this.migrateV2ToV3();
+      this.writeSchemaVersion(3);
+    }
+    if (currentVersion < 4) {
+      this.backupDatabase(dbPath);
+      this.migrateV3ToV4();
+      this.writeSchemaVersion(4);
+    }
+    if (currentVersion < 5) {
+      this.backupDatabase(dbPath);
+      this.migrateV4ToV5();
+      this.writeSchemaVersion(5);
+    }
+    if (currentVersion < 6) {
+      this.runSchema();
+      this.migrateV5ToV6();
+      this.writeSchemaVersion(6);
+    }
+  }
+  /** Backup the database to a .bak file. */
+  backupDatabase(dbPath) {
+    const backupPath = `${dbPath}.bak`;
+    try {
+      this.db.pragma("wal_checkpoint(FULL)");
+      copyFileSync(dbPath, backupPath);
+      console.error(`[remem-mcp] Backed up database to ${backupPath}`);
+    } catch (err) {
+      console.error(`[remem-mcp] Backup failed: ${err}`);
+    }
+  }
+  /** Run the schema.sql file. Idempotent. */
+  runSchema() {
+    const candidates = [
+      join(__dirname2, "storage", "schema.sql"),
+      join(__dirname2, "schema.sql"),
+      join(__dirname2, "..", "storage", "schema.sql")
+    ];
+    let schema = null;
+    for (const path of candidates) {
+      try {
+        schema = readFileSync(path, "utf-8");
+        break;
+      } catch {
+      }
+    }
+    if (!schema) {
+      throw new Error("Could not find schema.sql. Make sure the build copied it to dist/storage/.");
+    }
+    this.db.exec(schema);
+  }
+  /** Write the schema version to the schema_version table. */
+  writeSchemaVersion(version) {
+    this.db.prepare("INSERT INTO schema_version (version, applied_at) VALUES (?, ?)").run(version, Date.now());
+  }
+  /** Migrate schema v1 → v2: add content_hash column + index. */
+  migrateV1ToV2() {
+    const cols = this.db.prepare("PRAGMA table_info(captures)").all();
+    const hasContentHash = cols.some((c) => c.name === "content_hash");
+    if (!hasContentHash) {
+      this.db.exec("ALTER TABLE captures ADD COLUMN content_hash TEXT");
+      console.error("[remem-mcp] Added content_hash column to captures");
+    }
+    const idxs = this.db.prepare("SELECT name FROM sqlite_master WHERE type='index' AND name='idx_captures_hash'").get();
+    if (!idxs) {
+      this.db.exec("CREATE INDEX IF NOT EXISTS idx_captures_hash ON captures (content_hash)");
+    }
+    const rows = this.db.prepare("SELECT id, content FROM captures WHERE content_hash IS NULL").all();
+    const stmt = this.db.prepare("UPDATE captures SET content_hash = ? WHERE id = ?");
+    for (const row of rows) {
+      const hash = createHash("sha256").update(row.content).digest("hex");
+      stmt.run(hash, row.id);
+    }
+    if (rows.length > 0) {
+      console.error(`[remem-mcp] Backfilled content_hash for ${rows.length} existing captures`);
+    }
+  }
+  /** Migrate schema v2 → v3: add multi-tenant columns + new tables (messages, knowledge, skills, persona). */
+  migrateV2ToV3() {
+    const addColumnIfMissing = (table, column, definition) => {
+      const tableExists = this.db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name=?").get(table);
+      if (!tableExists) return;
+      const cols = this.db.prepare(`PRAGMA table_info(${table})`).all();
+      if (!cols.some((c) => c.name === column)) {
+        this.db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${definition}`);
+      }
+    };
+    addColumnIfMissing("captures", "team_id", "TEXT");
+    addColumnIfMissing("captures", "user_id", "TEXT");
+    addColumnIfMissing("captures", "task_id", "TEXT");
+    addColumnIfMissing("atoms", "team_id", "TEXT");
+    addColumnIfMissing("atoms", "agent_id", "TEXT");
+    addColumnIfMissing("atoms", "user_id", "TEXT");
+    addColumnIfMissing("scenarios", "team_id", "TEXT");
+    addColumnIfMissing("scenarios", "agent_id", "TEXT");
+    addColumnIfMissing("scenarios", "user_id", "TEXT");
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS messages (
+        id          TEXT PRIMARY KEY,
+        capture_id  TEXT NOT NULL REFERENCES captures(id) ON DELETE CASCADE,
+        role        TEXT NOT NULL,
+        content     TEXT NOT NULL,
+        seq         INTEGER NOT NULL,
+        created_at  INTEGER NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS persona (
+        team_id    TEXT NOT NULL,
+        agent_id   TEXT NOT NULL,
+        user_id    TEXT NOT NULL,
+        content    TEXT NOT NULL,
+        updated_at INTEGER NOT NULL,
+        PRIMARY KEY (team_id, agent_id, user_id)
+      );
+      CREATE TABLE IF NOT EXISTS knowledge (
+        id          TEXT PRIMARY KEY,
+        team_id     TEXT NOT NULL,
+        name        TEXT NOT NULL,
+        type        TEXT NOT NULL,
+        summary     TEXT,
+        service_url TEXT,
+        repo_url    TEXT,
+        branch      TEXT,
+        created_at  INTEGER NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS skills (
+        id          TEXT PRIMARY KEY,
+        team_id     TEXT NOT NULL,
+        agent_id    TEXT,
+        name        TEXT NOT NULL,
+        description TEXT,
+        content     TEXT,
+        version     INTEGER NOT NULL DEFAULT 1,
+        created_at  INTEGER NOT NULL,
+        updated_at  INTEGER NOT NULL
+      );
+    `);
+    console.error(
+      "[remem-mcp] Migrated schema v2 \u2192 v3 (multi-tenant + messages + knowledge + skills + persona)"
+    );
+  }
+  /** Migrate schema v3 → v4: add deleted_at column for soft delete (tombstone). */
+  migrateV3ToV4() {
+    const cols = this.db.prepare("PRAGMA table_info(captures)").all();
+    const hasDeletedAt = cols.some((c) => c.name === "deleted_at");
+    if (!hasDeletedAt) {
+      this.db.exec("ALTER TABLE captures ADD COLUMN deleted_at INTEGER");
+      console.error("[remem-mcp] Added deleted_at column to captures (tombstone support)");
+    }
+    console.error("[remem-mcp] Migrated schema v3 \u2192 v4 (tombstone / soft delete)");
+  }
+  /** Migrate schema v4 → v5: add trust_state, rejection_reason, superseded_by columns. */
+  migrateV4ToV5() {
+    const cols = this.db.prepare("PRAGMA table_info(captures)").all();
+    const hasTrustState = cols.some((c) => c.name === "trust_state");
+    if (!hasTrustState) {
+      this.db.exec("ALTER TABLE captures ADD COLUMN trust_state TEXT NOT NULL DEFAULT 'candidate'");
+      console.error("[remem-mcp] Added trust_state column to captures");
+    }
+    const hasRejectionReason = cols.some((c) => c.name === "rejection_reason");
+    if (!hasRejectionReason) {
+      this.db.exec("ALTER TABLE captures ADD COLUMN rejection_reason TEXT");
+      console.error("[remem-mcp] Added rejection_reason column to captures");
+    }
+    const hasSupersededBy = cols.some((c) => c.name === "superseded_by");
+    if (!hasSupersededBy) {
+      this.db.exec("ALTER TABLE captures ADD COLUMN superseded_by TEXT REFERENCES captures(id)");
+      console.error("[remem-mcp] Added superseded_by column to captures");
+    }
+    this.db.exec("CREATE INDEX IF NOT EXISTS idx_captures_trust ON captures (trust_state)");
+    this.db.exec(
+      "CREATE INDEX IF NOT EXISTS idx_captures_rejected_hash ON captures (content_hash) WHERE trust_state = 'rejected'"
+    );
+    console.error("[remem-mcp] Migrated schema v4 \u2192 v5 (trust state + correction)");
+  }
+  /** Migrate schema v5 → v6: add CodeGraph + Wiki tables (created by runSchema). */
+  migrateV5ToV6() {
+    console.error("[remem-mcp] Migrated schema v5 \u2192 v6 (CodeGraph + Wiki tables)");
+  }
+  async put(entry) {
+    const contentHash = entry.contentHash ?? createHash("sha256").update(entry.content).digest("hex");
+    const stmt = this.db.prepare(`
+      INSERT INTO captures (id, session_key, agent_id, type, content, content_hash, tags, created_at, metadata, team_id, user_id, task_id, trust_state)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    stmt.run(
+      entry.id,
+      entry.sessionKey,
+      entry.agentId,
+      entry.type,
+      entry.content,
+      contentHash,
+      JSON.stringify(entry.tags),
+      entry.createdAt,
+      entry.metadata ? JSON.stringify(entry.metadata) : null,
+      entry.teamId ?? null,
+      entry.userId ?? null,
+      entry.taskId ?? null,
+      entry.trustState ?? "candidate"
+    );
+    if (entry.messages && entry.messages.length > 0) {
+      const msgStmt = this.db.prepare(
+        "INSERT INTO messages (id, capture_id, role, content, seq, created_at) VALUES (?, ?, ?, ?, ?, ?)"
+      );
+      for (let i = 0; i < entry.messages.length; i++) {
+        const msg = entry.messages[i];
+        msgStmt.run(generateId(), entry.id, msg.role, msg.content, i, entry.createdAt);
+      }
+    }
+  }
+  async putVector(id, embedding) {
+    const buffer = new Float32Array(embedding);
+    const stmt = this.db.prepare("INSERT INTO captures_vec (id, embedding) VALUES (?, ?)");
+    stmt.run(id, Buffer.from(buffer.buffer));
+  }
+  async get(id) {
+    const row = this.db.prepare("SELECT * FROM captures WHERE id = ? AND deleted_at IS NULL").get(id);
+    if (!row) return null;
+    return rowToEntry(row);
+  }
+  async findRejectedByContentHash(contentHash, sessionKey) {
+    let sql = "SELECT * FROM captures WHERE content_hash = ? AND trust_state = 'rejected'";
+    const params = [contentHash];
+    if (sessionKey) {
+      sql += " AND session_key = ?";
+      params.push(sessionKey);
+    }
+    const rows = this.db.prepare(sql).all(...params);
+    return rows.map(rowToEntry);
+  }
+  async getMessages(captureId) {
+    const rows = this.db.prepare("SELECT * FROM messages WHERE capture_id = ? ORDER BY seq ASC").all(captureId);
+    return rows.map((r) => ({
+      id: r.id,
+      captureId: r.capture_id,
+      role: r.role,
+      content: r.content,
+      seq: r.seq,
+      createdAt: r.created_at
+    }));
+  }
+  async findByContentHash(contentHash, sessionKey) {
+    let sql = "SELECT * FROM captures WHERE content_hash = ? AND deleted_at IS NULL";
+    const params = [contentHash];
+    if (sessionKey) {
+      sql += " AND session_key = ?";
+      params.push(sessionKey);
+    }
+    const rows = this.db.prepare(sql).all(...params);
+    return rows.map(rowToEntry);
+  }
+  async listByTags(tags, limit = 50) {
+    if (tags.length === 0) return [];
+    const tagConditions = tags.map(() => "tags LIKE ?").join(" OR ");
+    const sql = `SELECT * FROM captures WHERE (${tagConditions}) AND deleted_at IS NULL AND trust_state != 'rejected' ORDER BY created_at DESC LIMIT ?`;
+    const params = [...tags.map((t) => `%"${t}"%`), limit];
+    const rows = this.db.prepare(sql).all(...params);
+    return rows.map(rowToEntry);
+  }
+  async search(query, queryEmbedding, opts) {
+    const { mode, limit, offset, sessionKey, filters } = opts;
+    const temporalIntent = /\b(currently|current|now|latest|new|present|today|active)\b/i.test(query);
+    let bm25Results = [];
+    let vecResults = [];
+    const bm25CandidateLimit = mode === "hybrid" ? limit * 2 : limit * 2;
+    const vecCandidateLimit = mode === "hybrid" ? Math.min(Math.max(limit * 10, 100), 1e3) : limit * 2;
+    if (mode === "hybrid" || mode === "keyword") {
+      bm25Results = this.bm25Search(query, bm25CandidateLimit, sessionKey, filters);
+    }
+    if ((mode === "hybrid" || mode === "vector") && queryEmbedding) {
+      vecResults = this.vectorSearch(queryEmbedding, vecCandidateLimit, sessionKey, filters);
+    }
+    if (mode === "keyword") {
+      return this.fetchEntries(bm25Results, limit, offset, temporalIntent);
+    }
+    if (mode === "vector") {
+      return this.fetchEntries(vecResults, limit, offset, temporalIntent);
+    }
+    const fused = rrfMerge(bm25Results, vecResults, limit + offset);
+    const paged = fused.slice(offset, offset + limit);
+    return this.fetchEntriesById(paged, temporalIntent);
+  }
+  /** Run a BM25 search via FTS5. */
+  bm25Search(query, limit, sessionKey, filters) {
+    const ftsQuery = this.escapeFtsQuery(query);
+    if (!ftsQuery) return [];
+    let sql;
+    const params = [ftsQuery];
+    try {
+      sql = `
+      SELECT fts.id as id, bm25(captures_fts) as score
+      FROM captures_fts fts
+      JOIN captures c ON c.id = fts.id
+      WHERE captures_fts MATCH ? AND c.deleted_at IS NULL AND c.trust_state != 'rejected'
+    `;
+      if (sessionKey) {
+        sql += " AND c.session_key = ?";
+        params.push(sessionKey);
+      }
+      if (filters?.type) {
+        sql += " AND c.type = ?";
+        params.push(filters.type);
+      }
+      if (filters?.agentId) {
+        sql += " AND c.agent_id = ?";
+        params.push(filters.agentId);
+      }
+      if (filters?.teamId) {
+        sql += " AND c.team_id = ?";
+        params.push(filters.teamId);
+      }
+      if (filters?.userId) {
+        sql += " AND c.user_id = ?";
+        params.push(filters.userId);
+      }
+      if (filters?.taskId) {
+        sql += " AND c.task_id = ?";
+        params.push(filters.taskId);
+      }
+      if (filters?.tags && filters.tags.length > 0) {
+        const tagConditions = filters.tags.map(() => "c.tags LIKE ?").join(" OR ");
+        sql += ` AND (${tagConditions})`;
+        params.push(...filters.tags.map((t) => `%"${t}"%`));
+      }
+      if (filters?.dateFrom) {
+        sql += " AND c.created_at >= ?";
+        params.push(new Date(filters.dateFrom).getTime());
+      }
+      if (filters?.dateTo) {
+        sql += " AND c.created_at <= ?";
+        params.push(new Date(filters.dateTo).getTime());
+      }
+      sql += " ORDER BY score LIMIT ?";
+      params.push(limit);
+      const rows = this.db.prepare(sql).all(...params);
+      return rows.map((r) => ({ id: r.id, score: r.score }));
+    } catch (err) {
+      if (err instanceof Error && err.message.includes("missing row")) {
+        this.db.exec("INSERT INTO captures_fts(captures_fts) VALUES('rebuild')");
+        const rows = this.db.prepare(sql).all(...params);
+        return rows.map((r) => ({ id: r.id, score: r.score }));
+      }
+      throw err;
+    }
+  }
+  /** Run a vector search via sqlite-vec. */
+  vectorSearch(embedding, limit, sessionKey, filters) {
+    const buffer = new Float32Array(embedding);
+    let sql = `
+      SELECT vec.id as id, vec.distance as score
+      FROM captures_vec vec
+      JOIN captures c ON c.id = vec.id
+      WHERE vec.embedding MATCH ? AND vec.k = ? AND c.deleted_at IS NULL AND c.trust_state != 'rejected'
+    `;
+    const params = [Buffer.from(buffer.buffer), limit];
+    if (sessionKey) {
+      sql += " AND c.session_key = ?";
+      params.push(sessionKey);
+    }
+    if (filters?.type) {
+      sql += " AND c.type = ?";
+      params.push(filters.type);
+    }
+    if (filters?.agentId) {
+      sql += " AND c.agent_id = ?";
+      params.push(filters.agentId);
+    }
+    if (filters?.teamId) {
+      sql += " AND c.team_id = ?";
+      params.push(filters.teamId);
+    }
+    if (filters?.userId) {
+      sql += " AND c.user_id = ?";
+      params.push(filters.userId);
+    }
+    if (filters?.taskId) {
+      sql += " AND c.task_id = ?";
+      params.push(filters.taskId);
+    }
+    if (filters?.tags && filters.tags.length > 0) {
+      const tagConditions = filters.tags.map(() => "c.tags LIKE ?").join(" OR ");
+      sql += ` AND (${tagConditions})`;
+      params.push(...filters.tags.map((t) => `%"${t}"%`));
+    }
+    if (filters?.dateFrom) {
+      sql += " AND c.created_at >= ?";
+      params.push(new Date(filters.dateFrom).getTime());
+    }
+    if (filters?.dateTo) {
+      sql += " AND c.created_at <= ?";
+      params.push(new Date(filters.dateTo).getTime());
+    }
+    sql += " ORDER BY vec.distance LIMIT ?";
+    params.push(limit);
+    const rows = this.db.prepare(sql).all(...params);
+    return rows.map((r) => ({ id: r.id, score: r.score }));
+  }
+  /** Fetch capture entries for a list of ranked results. */
+  async fetchEntries(results, limit, offset, temporalIntent = false) {
+    const paged = results.slice(offset, offset + limit);
+    return this.fetchEntriesById(paged, temporalIntent);
+  }
+  /** Fetch capture entries by ID, preserving the order of the input list. Applies memory decay and trust-state ranking. */
+  async fetchEntriesById(results, temporalIntent = false) {
+    if (results.length === 0) return [];
+    const ids = results.map((r) => r.id);
+    const placeholders = ids.map(() => "?").join(",");
+    const rows = this.db.prepare(`SELECT * FROM captures WHERE id IN (${placeholders})`).all(...ids);
+    const rowMap = new Map(rows.map((r) => [r.id, r]));
+    const now = Date.now();
+    const HALF_LIFE_MS = 30 * 24 * 60 * 60 * 1e3;
+    const TRUST_BOOST = {
+      verified: 1.5,
+      candidate: 1,
+      stale: 0.1,
+      rejected: 0
+    };
+    const recencyWeight = temporalIntent ? 0.5 : 0.3;
+    return results.map((r) => {
+      const row = rowMap.get(r.id);
+      if (!row) return null;
+      const ageMs = now - row.created_at;
+      const decay = 0.5 ** (ageMs / HALF_LIFE_MS);
+      const trustBoost = TRUST_BOOST[row.trust_state ?? "candidate"] ?? 1;
+      const decayed = Number.isNaN(r.score) ? 0 : r.score * decay;
+      const finalScore = decayed >= 0 ? decayed * trustBoost : decayed / trustBoost;
+      const recencyDecayMs = temporalIntent ? 1e3 : 1e4;
+      const recencyBias = 1 / (1 + ageMs / recencyDecayMs);
+      const biasedScore = finalScore >= 0 ? finalScore * (1 + recencyBias * recencyWeight) : finalScore / (1 + recencyBias * recencyWeight);
+      return { entry: rowToEntry(row), score: biasedScore };
+    }).filter((r) => r !== null).filter((r) => !temporalIntent || r.entry.trustState !== "stale").sort((a, b) => {
+      if (temporalIntent) {
+        const timeDiff = b.entry.createdAt - a.entry.createdAt;
+        if (Math.abs(timeDiff) > 50) return timeDiff;
+      }
+      return b.score - a.score;
+    });
+  }
+  /** Escape a query string for FTS5 MATCH.
+   *  Uses OR semantics with stopword removal for high recall.
+   *  AND semantics (all tokens must match) is too strict for natural language
+   *  questions — a 15-word query rarely has every token in a single capture,
+   *  causing BM25 to return zero results. OR semantics lets BM25 rank by
+   *  relevance (documents matching more terms rank higher) while still
+   *  returning partial matches. RRF fusion with weighted vector search
+   *  filters out BM25 noise.
+   */
+  escapeFtsQuery(query) {
+    const FTS_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",
+      "must",
+      "can",
+      "shall",
+      "i",
+      "you",
+      "he",
+      "she",
+      "it",
+      "we",
+      "they",
+      "me",
+      "him",
+      "her",
+      "us",
+      "them",
+      "my",
+      "your",
+      "his",
+      "its",
+      "our",
+      "their",
+      "this",
+      "that",
+      "these",
+      "those",
+      "and",
+      "or",
+      "but",
+      "not",
+      "no",
+      "nor",
+      "so",
+      "yet",
+      "in",
+      "on",
+      "at",
+      "to",
+      "for",
+      "of",
+      "with",
+      "by",
+      "from",
+      "as",
+      "about",
+      "into",
+      "through",
+      "during",
+      "before",
+      "after",
+      "what",
+      "when",
+      "where",
+      "which",
+      "who",
+      "how",
+      "why",
+      "since",
+      "because",
+      "if",
+      "then",
+      "than"
+    ]);
+    const tokens = query.trim().split(/\s+/).filter(Boolean);
+    if (tokens.length === 0) return "";
+    const filtered = tokens.filter((t) => !FTS_STOPWORDS.has(t.toLowerCase()));
+    const finalTokens = filtered.length > 0 ? filtered : tokens;
+    return finalTokens.map((t) => `"${t.replace(/"/g, '""')}"`).join(" OR ");
+  }
+  async delete(id) {
+    const now = Date.now();
+    const captureCount = this.db.prepare("UPDATE captures SET deleted_at = ? WHERE id = ? AND deleted_at IS NULL").run(now, id).changes;
+    if (captureCount > 0) {
+      this.db.prepare("DELETE FROM captures_vec WHERE id = ?").run(id);
+      const rowid = this.db.prepare("SELECT rowid FROM captures WHERE id = ?").get(id);
+      if (rowid) {
+        this.db.prepare(
+          "INSERT INTO captures_fts(captures_fts, rowid, content, tags, type) VALUES('delete', ?, '', '', '')"
+        ).run(rowid.rowid);
+      }
+    }
+    return {
+      captures: captureCount,
+      atoms: 0,
+      scenarios: 0
+    };
+  }
+  async deleteByFilter(filter) {
+    let sql = "SELECT id FROM captures WHERE deleted_at IS NULL";
+    const params = [];
+    if (filter.type) {
+      sql += " AND type = ?";
+      params.push(filter.type);
+    }
+    if (filter.dateBefore) {
+      sql += " AND created_at < ?";
+      params.push(new Date(filter.dateBefore).getTime());
+    }
+    if (filter.teamId) {
+      sql += " AND team_id = ?";
+      params.push(filter.teamId);
+    }
+    if (filter.userId) {
+      sql += " AND user_id = ?";
+      params.push(filter.userId);
+    }
+    if (filter.taskId) {
+      sql += " AND task_id = ?";
+      params.push(filter.taskId);
+    }
+    if (filter.tags && filter.tags.length > 0) {
+      const tagConditions = filter.tags.map(() => "tags LIKE ?").join(" OR ");
+      sql += ` AND (${tagConditions})`;
+      params.push(...filter.tags.map((t) => `%"${t}"%`));
+    }
+    const ids = this.db.prepare(sql).all(...params);
+    let captures = 0;
+    let atoms = 0;
+    let scenarios = 0;
+    for (const { id } of ids) {
+      const result = await this.delete(id);
+      captures += result.captures;
+      atoms += result.atoms;
+      scenarios += result.scenarios;
+    }
+    return { captures, atoms, scenarios };
+  }
+  async reject(id, reason) {
+    const now = Date.now();
+    const captureCount = this.db.prepare(
+      "UPDATE captures SET trust_state = 'rejected', rejection_reason = ?, deleted_at = ? WHERE id = ? AND deleted_at IS NULL AND trust_state != 'rejected'"
+    ).run(reason, now, id).changes;
+    if (captureCount > 0) {
+      this.db.prepare("DELETE FROM captures_vec WHERE id = ?").run(id);
+      const rowid = this.db.prepare("SELECT rowid FROM captures WHERE id = ?").get(id);
+      if (rowid) {
+        this.db.prepare(
+          "INSERT INTO captures_fts(captures_fts, rowid, content, tags, type) VALUES('delete', ?, '', '', '')"
+        ).run(rowid.rowid);
+      }
+    }
+    return { captures: captureCount, atoms: 0, scenarios: 0 };
+  }
+  async findConflicts(embedding, sessionKey, threshold) {
+    const buffer = new Float32Array(embedding);
+    const rows = this.db.prepare(
+      `SELECT vec.id as id, vec.distance as distance, c.content as content, c.trust_state as trust_state
+         FROM captures_vec vec
+         JOIN captures c ON c.id = vec.id
+         WHERE vec.embedding MATCH ? AND vec.k = 20
+           AND c.deleted_at IS NULL
+           AND c.trust_state IN ('candidate', 'verified')
+           AND c.session_key = ?
+         ORDER BY vec.distance
+         LIMIT 10`
+    ).all(Buffer.from(buffer.buffer), sessionKey);
+    return rows.filter((r) => {
+      const cosineDist = r.distance * r.distance / 2;
+      return cosineDist < threshold;
+    }).map((r) => ({
+      id: r.id,
+      content: r.content,
+      // Return cosine distance (not L2) so the caller gets a meaningful value.
+      distance: r.distance * r.distance / 2,
+      trustState: r.trust_state
+    }));
+  }
+  async supersede(loserId, winnerId) {
+    const updated = this.db.prepare(
+      "UPDATE captures SET trust_state = 'stale', superseded_by = ? WHERE id = ? AND deleted_at IS NULL AND trust_state != 'rejected'"
+    ).run(winnerId, loserId).changes;
+    return { winnerId, loserId, updated };
+  }
+  async setTrustState(id, state) {
+    return this.db.prepare("UPDATE captures SET trust_state = ? WHERE id = ? AND deleted_at IS NULL").run(state, id).changes;
+  }
+  // ─── L1 atoms ───────────────────────────────────────────────
+  async putAtom(atom) {
+    this.db.prepare(
+      "INSERT INTO atoms (id, capture_id, fact, confidence, created_at, team_id, agent_id, user_id) VALUES (?, ?, ?, ?, ?, ?, ?, ?)"
+    ).run(
+      atom.id,
+      atom.captureId,
+      atom.fact,
+      atom.confidence,
+      atom.createdAt,
+      atom.teamId ?? null,
+      atom.agentId ?? null,
+      atom.userId ?? null
+    );
+  }
+  async listAtoms(opts) {
+    let sql = "SELECT * FROM atoms WHERE 1=1";
+    const params = [];
+    if (opts.teamId) {
+      sql += " AND team_id = ?";
+      params.push(opts.teamId);
+    }
+    if (opts.agentId) {
+      sql += " AND agent_id = ?";
+      params.push(opts.agentId);
+    }
+    if (opts.userId) {
+      sql += " AND user_id = ?";
+      params.push(opts.userId);
+    }
+    if (opts.captureId) {
+      sql += " AND capture_id = ?";
+      params.push(opts.captureId);
+    }
+    sql += " ORDER BY created_at DESC LIMIT ? OFFSET ?";
+    params.push(opts.limit ?? 20, opts.offset ?? 0);
+    const rows = this.db.prepare(sql).all(...params);
+    return rows.map((r) => ({
+      id: r.id,
+      captureId: r.capture_id,
+      fact: r.fact,
+      confidence: r.confidence,
+      createdAt: r.created_at,
+      teamId: r.team_id ?? void 0,
+      agentId: r.agent_id ?? void 0,
+      userId: r.user_id ?? void 0
+    }));
+  }
+  async searchAtoms(query, opts = {}) {
+    let sql = "SELECT * FROM atoms WHERE fact LIKE ?";
+    const params = [`%${query}%`];
+    if (opts.teamId) {
+      sql += " AND team_id = ?";
+      params.push(opts.teamId);
+    }
+    if (opts.agentId) {
+      sql += " AND agent_id = ?";
+      params.push(opts.agentId);
+    }
+    if (opts.userId) {
+      sql += " AND user_id = ?";
+      params.push(opts.userId);
+    }
+    sql += " ORDER BY created_at DESC LIMIT ?";
+    params.push(opts.limit ?? 20);
+    const rows = this.db.prepare(sql).all(...params);
+    return rows.map((r) => ({
+      id: r.id,
+      captureId: r.capture_id,
+      fact: r.fact,
+      confidence: r.confidence,
+      createdAt: r.created_at,
+      teamId: r.team_id ?? void 0,
+      agentId: r.agent_id ?? void 0,
+      userId: r.user_id ?? void 0
+    }));
+  }
+  // ─── L2 scenarios ───────────────────────────────────────────
+  async putScenario(scenario) {
+    this.db.prepare(
+      "INSERT INTO scenarios (id, atom_ids, summary, persona_tags, created_at, team_id, agent_id, user_id) VALUES (?, ?, ?, ?, ?, ?, ?, ?)"
+    ).run(
+      scenario.id,
+      JSON.stringify(scenario.atomIds),
+      scenario.summary,
+      scenario.personaTags ? JSON.stringify(scenario.personaTags) : null,
+      scenario.createdAt,
+      scenario.teamId ?? null,
+      scenario.agentId ?? null,
+      scenario.userId ?? null
+    );
+  }
+  async listScenarios(opts) {
+    let sql = "SELECT * FROM scenarios WHERE 1=1";
+    const params = [];
+    if (opts.teamId) {
+      sql += " AND team_id = ?";
+      params.push(opts.teamId);
+    }
+    if (opts.agentId) {
+      sql += " AND agent_id = ?";
+      params.push(opts.agentId);
+    }
+    if (opts.userId) {
+      sql += " AND user_id = ?";
+      params.push(opts.userId);
+    }
+    sql += " ORDER BY created_at DESC LIMIT ? OFFSET ?";
+    params.push(opts.limit ?? 20, opts.offset ?? 0);
+    const rows = this.db.prepare(sql).all(...params);
+    return rows.map((r) => ({
+      id: r.id,
+      atomIds: JSON.parse(r.atom_ids),
+      summary: r.summary,
+      personaTags: r.persona_tags ? JSON.parse(r.persona_tags) : void 0,
+      createdAt: r.created_at,
+      teamId: r.team_id ?? void 0,
+      agentId: r.agent_id ?? void 0,
+      userId: r.user_id ?? void 0
+    }));
+  }
+  async getScenario(id) {
+    const row = this.db.prepare("SELECT * FROM scenarios WHERE id = ?").get(id);
+    if (!row) return null;
+    return {
+      id: row.id,
+      atomIds: JSON.parse(row.atom_ids),
+      summary: row.summary,
+      personaTags: row.persona_tags ? JSON.parse(row.persona_tags) : void 0,
+      createdAt: row.created_at,
+      teamId: row.team_id ?? void 0,
+      agentId: row.agent_id ?? void 0,
+      userId: row.user_id ?? void 0
+    };
+  }
+  // ─── L3 persona ─────────────────────────────────────────────
+  async readPersona(teamId, agentId, userId) {
+    const row = this.db.prepare("SELECT * FROM persona WHERE team_id = ? AND agent_id = ? AND user_id = ?").get(teamId, agentId, userId);
+    if (!row) return null;
+    return {
+      teamId: row.team_id,
+      agentId: row.agent_id,
+      userId: row.user_id,
+      content: row.content,
+      updatedAt: row.updated_at
+    };
+  }
+  async writePersona(teamId, agentId, userId, content) {
+    this.db.prepare(
+      `INSERT INTO persona (team_id, agent_id, user_id, content, updated_at)
+         VALUES (?, ?, ?, ?, ?)
+         ON CONFLICT(team_id, agent_id, user_id) DO UPDATE SET content = excluded.content, updated_at = excluded.updated_at`
+    ).run(teamId, agentId, userId, content, Date.now());
+  }
+  // ─── Knowledge ──────────────────────────────────────────────
+  async putKnowledge(entry) {
+    this.db.prepare(
+      "INSERT INTO knowledge (id, team_id, name, type, summary, service_url, repo_url, branch, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)"
+    ).run(
+      entry.id,
+      entry.teamId,
+      entry.name,
+      entry.type,
+      entry.summary ?? null,
+      entry.serviceUrl ?? null,
+      entry.repoUrl ?? null,
+      entry.branch ?? null,
+      entry.createdAt
+    );
+  }
+  async getKnowledge(id) {
+    const row = this.db.prepare("SELECT * FROM knowledge WHERE id = ?").get(id);
+    if (!row) return null;
+    return knowledgeRowToEntry(row);
+  }
+  async listKnowledge(teamId, type) {
+    let sql = "SELECT * FROM knowledge WHERE team_id = ?";
+    const params = [teamId];
+    if (type) {
+      sql += " AND type = ?";
+      params.push(type);
+    }
+    sql += " ORDER BY created_at DESC";
+    const rows = this.db.prepare(sql).all(...params);
+    return rows.map(knowledgeRowToEntry);
+  }
+  async deleteKnowledge(ids) {
+    if (ids.length === 0) return 0;
+    const placeholders = ids.map(() => "?").join(",");
+    const result = this.db.prepare(`DELETE FROM knowledge WHERE id IN (${placeholders})`).run(...ids);
+    return result.changes;
+  }
+  // ─── Skills ─────────────────────────────────────────────────
+  async putSkill(entry) {
+    this.db.prepare(
+      `INSERT INTO skills (id, team_id, agent_id, name, description, content, version, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT(id) DO UPDATE SET name = excluded.name, description = excluded.description, content = excluded.content, version = excluded.version, updated_at = excluded.updated_at`
+    ).run(
+      entry.id,
+      entry.teamId,
+      entry.agentId ?? null,
+      entry.name,
+      entry.description ?? null,
+      entry.content ?? null,
+      entry.version,
+      entry.createdAt,
+      entry.updatedAt
+    );
+  }
+  async getSkill(id) {
+    const row = this.db.prepare("SELECT * FROM skills WHERE id = ?").get(id);
+    if (!row) return null;
+    return skillRowToEntry(row);
+  }
+  async listSkills(teamId, agentId) {
+    let sql = "SELECT * FROM skills WHERE team_id = ?";
+    const params = [teamId];
+    if (agentId) {
+      sql += " AND (agent_id = ? OR agent_id IS NULL)";
+      params.push(agentId);
+    }
+    sql += " ORDER BY updated_at DESC";
+    const rows = this.db.prepare(sql).all(...params);
+    return rows.map(skillRowToEntry);
+  }
+  async searchSkills(teamId, agentId, query, topK) {
+    let sql = "SELECT * FROM skills WHERE team_id = ? AND (agent_id = ? OR agent_id IS NULL) AND (name LIKE ? OR description LIKE ?)";
+    const params = [teamId, agentId, `%${query}%`, `%${query}%`];
+    sql += " ORDER BY updated_at DESC LIMIT ?";
+    params.push(topK ?? 10);
+    const rows = this.db.prepare(sql).all(...params);
+    return rows.map(skillRowToEntry);
+  }
+  close() {
+    this.db.close();
+  }
+};
+function rowToEntry(row) {
+  return {
+    id: row.id,
+    sessionKey: row.session_key,
+    agentId: row.agent_id,
+    type: row.type,
+    content: row.content,
+    tags: row.tags ? JSON.parse(row.tags) : [],
+    createdAt: row.created_at,
+    metadata: row.metadata ? JSON.parse(row.metadata) : void 0,
+    teamId: row.team_id ?? void 0,
+    userId: row.user_id ?? void 0,
+    taskId: row.task_id ?? void 0,
+    trustState: row.trust_state ?? "candidate",
+    rejectionReason: row.rejection_reason ?? void 0,
+    supersededBy: row.superseded_by ?? void 0
+  };
+}
+function knowledgeRowToEntry(row) {
+  return {
+    id: row.id,
+    teamId: row.team_id,
+    name: row.name,
+    type: row.type,
+    summary: row.summary ?? void 0,
+    serviceUrl: row.service_url ?? void 0,
+    repoUrl: row.repo_url ?? void 0,
+    branch: row.branch ?? void 0,
+    createdAt: row.created_at
+  };
+}
+function skillRowToEntry(row) {
+  return {
+    id: row.id,
+    teamId: row.team_id,
+    agentId: row.agent_id ?? void 0,
+    name: row.name,
+    description: row.description ?? void 0,
+    content: row.content ?? void 0,
+    version: row.version,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+
+// src/wiki/engine.ts
+init_esm_shims();
+import { createHash as createHash2 } from "crypto";
+import { existsSync as existsSync2, readdirSync, readFileSync as readFileSync2, statSync } from "fs";
+import { basename, extname, join as join2, relative, sep } from "path";
+function parseFrontmatter(content) {
+  if (!content.startsWith("---")) {
+    return { frontmatter: null, body: content };
+  }
+  const end = content.indexOf("\n---", 3);
+  if (end === -1) {
+    return { frontmatter: null, body: content };
+  }
+  const frontmatter = content.slice(3, end).trim();
+  const body = content.slice(end + 4).replace(/^\n/, "");
+  return { frontmatter, body };
+}
+function extractTags(frontmatter) {
+  if (!frontmatter) return null;
+  const match = frontmatter.match(/^tags:\s*(.+)$/m);
+  if (!match) return null;
+  return match[1].replace(/[[\]]/g, "").trim();
+}
+function extractTitle(frontmatter, body, fileName) {
+  if (frontmatter) {
+    const titleMatch = frontmatter.match(/^title:\s*(.+)$/m);
+    if (titleMatch) return titleMatch[1].replace(/["']/g, "").trim();
+  }
+  const h1Match = body.match(/^#\s+(.+)$/m);
+  if (h1Match) return h1Match[1].trim();
+  return basename(fileName, extname(fileName));
+}
+function extractWikilinks(content) {
+  const links = [];
+  const lines = content.split("\n");
+  const regex = /\[\[([^\]|]+)(?:\|([^\]]+))?\]\]/g;
+  for (let i = 0; i < lines.length; i++) {
+    let match;
+    regex.lastIndex = 0;
+    match = regex.exec(lines[i]);
+    while (match !== null) {
+      links.push({
+        target: match[1].trim(),
+        text: (match[2] ?? match[1]).trim(),
+        line: i + 1
+      });
+      match = regex.exec(lines[i]);
+    }
+  }
+  return links;
+}
+function extractMarkdownLinks(content) {
+  const links = [];
+  const lines = content.split("\n");
+  const regex = /(?<!!)\[([^\]]+)\]\(([^)]+)\)/g;
+  for (let i = 0; i < lines.length; i++) {
+    let match;
+    regex.lastIndex = 0;
+    match = regex.exec(lines[i]);
+    while (match !== null) {
+      const target = match[2].trim();
+      if (!target.startsWith("http") && !target.startsWith("mailto:")) {
+        links.push({
+          target: target.replace(/\.md$/i, ""),
+          text: match[1].trim(),
+          line: i + 1
+        });
+      }
+      match = regex.exec(lines[i]);
+    }
+  }
+  return links;
+}
+function parseMarkdownFile(filePath, repoPath) {
+  const ext = extname(filePath).toLowerCase();
+  if (ext !== ".md" && ext !== ".markdown") return null;
+  let source;
+  try {
+    source = readFileSync2(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+  const relPath = relative(repoPath, filePath).split(sep).join("/");
+  const { frontmatter, body } = parseFrontmatter(source);
+  const title = extractTitle(frontmatter, body, filePath);
+  const tags = extractTags(frontmatter);
+  const contentHash = createHash2("sha256").update(source).digest("hex");
+  const page = {
+    id: generateId(),
+    title,
+    content: body,
+    sourceFile: relPath,
+    section: null,
+    tags,
+    frontmatter,
+    contentHash
+  };
+  const wikilinks = extractWikilinks(body).map((l) => ({ ...l, type: "wikilink" }));
+  const mdlinks = extractMarkdownLinks(body).map((l) => ({ ...l, type: "markdown" }));
+  const links = [...wikilinks, ...mdlinks];
+  return { page, links };
+}
+function ingestFile(db, filePath, repoPath, teamId) {
+  const ext = extname(filePath).toLowerCase();
+  if (ext !== ".md" && ext !== ".markdown") {
+    return { file: filePath, pages: 0, links: 0, skipped: true, reason: "not markdown" };
+  }
+  const parsed = parseMarkdownFile(filePath, repoPath);
+  if (!parsed) {
+    return { file: filePath, pages: 0, links: 0, skipped: true, reason: "parse failed" };
+  }
+  const relPath = relative(repoPath, filePath).split(sep).join("/");
+  const now = Date.now();
+  const existing = db.prepare("SELECT id FROM wiki_pages WHERE source_file = ? AND team_id IS ?").get(relPath, teamId);
+  let pageId = parsed.page.id;
+  if (existing) {
+    pageId = existing.id;
+    db.prepare(
+      "UPDATE wiki_pages SET title = ?, content = ?, tags = ?, frontmatter = ?, content_hash = ?, updated_at = ? WHERE id = ?"
+    ).run(
+      parsed.page.title,
+      parsed.page.content,
+      parsed.page.tags,
+      parsed.page.frontmatter,
+      parsed.page.contentHash,
+      now,
+      pageId
+    );
+    db.prepare("DELETE FROM wiki_links WHERE from_page_id = ?").run(pageId);
+  } else {
+    db.prepare(
+      `INSERT INTO wiki_pages (id, title, content, source_file, section, tags, frontmatter, content_hash, team_id, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      parsed.page.id,
+      parsed.page.title,
+      parsed.page.content,
+      parsed.page.sourceFile,
+      parsed.page.section,
+      parsed.page.tags,
+      parsed.page.frontmatter,
+      parsed.page.contentHash,
+      teamId,
+      now,
+      now
+    );
+  }
+  const linkStmt = db.prepare(
+    "INSERT INTO wiki_links (from_page_id, to_page_id, to_title, link_text, link_type, line) VALUES (?, ?, ?, ?, ?, ?)"
+  );
+  for (const link of parsed.links) {
+    const target = db.prepare("SELECT id FROM wiki_pages WHERE title = ? AND team_id IS ? LIMIT 1").get(link.target, teamId);
+    linkStmt.run(pageId, target?.id ?? null, link.target, link.text, link.type, link.line);
+  }
+  return {
+    file: relPath,
+    pages: 1,
+    links: parsed.links.length,
+    skipped: false
+  };
+}
+function ingestDirectory(db, dirPath, repoPath, teamId, maxFiles = 200) {
+  const results = [];
+  const files = [];
+  const walk = (dir) => {
+    if (files.length >= maxFiles) return;
+    let entries;
+    try {
+      entries = readdirSync(dir);
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (files.length >= maxFiles) return;
+      const fullPath = join2(dir, entry);
+      let stat;
+      try {
+        stat = statSync(fullPath);
+      } catch {
+        continue;
+      }
+      if (stat.isDirectory()) {
+        if (entry.startsWith(".") || entry === "node_modules" || entry === "vendor") continue;
+        walk(fullPath);
+      } else if (stat.isFile()) {
+        const ext = extname(fullPath).toLowerCase();
+        if (ext === ".md" || ext === ".markdown") {
+          files.push(fullPath);
+        }
+      }
+    }
+  };
+  walk(dirPath);
+  for (const file of files) {
+    const result = ingestFile(db, file, repoPath, teamId);
+    results.push(result);
+  }
+  const unresolved = db.prepare("SELECT id, to_title FROM wiki_links WHERE to_page_id IS NULL").all();
+  if (unresolved.length > 0) {
+    const updateStmt = db.prepare("UPDATE wiki_links SET to_page_id = ? WHERE id = ?");
+    for (const u of unresolved) {
+      const target = db.prepare("SELECT id FROM wiki_pages WHERE title = ? AND team_id IS ? LIMIT 1").get(u.to_title, teamId);
+      if (target) {
+        updateStmt.run(target.id, u.id);
+      }
+    }
+  }
+  return results;
+}
+function searchWiki(db, query, opts = {}) {
+  const limit = opts.limit ?? 10;
+  let sql = `
+    SELECT w.id, w.title, w.source_file, snippet(wiki_fts, 1, '<b>', '</b>', '...', 20) as snippet
+    FROM wiki_fts f
+    JOIN wiki_pages w ON w.id = f.id
+    WHERE wiki_fts MATCH ?
+  `;
+  const params = [query];
+  if (opts.teamId !== void 0) {
+    sql += " AND w.team_id IS ?";
+    params.push(opts.teamId);
+  }
+  sql += " LIMIT ?";
+  params.push(limit);
+  const rows = db.prepare(sql).all(...params);
+  return rows.map((r) => ({
+    id: r.id,
+    title: r.title,
+    sourceFile: r.source_file,
+    snippet: r.snippet
+  }));
+}
+function getWikiPage(db, pageId) {
+  const row = db.prepare("SELECT * FROM wiki_pages WHERE id = ?").get(pageId);
+  if (!row) return null;
+  const page = {
+    id: row.id,
+    title: row.title,
+    content: row.content,
+    sourceFile: row.source_file,
+    section: row.section,
+    tags: row.tags,
+    frontmatter: row.frontmatter,
+    contentHash: row.content_hash
+  };
+  const linkRows = db.prepare("SELECT * FROM wiki_links WHERE from_page_id = ? ORDER BY line").all(pageId);
+  const links = linkRows.map((r) => ({
+    fromPageId: r.from_page_id,
+    toPageId: r.to_page_id,
+    toTitle: r.to_title,
+    linkText: r.link_text,
+    linkType: r.link_type,
+    line: r.line
+  }));
+  const backlinkRows = db.prepare("SELECT * FROM wiki_links WHERE to_page_id = ? ORDER BY line").all(pageId);
+  const backlinks = backlinkRows.map((r) => ({
+    fromPageId: r.from_page_id,
+    toPageId: r.to_page_id,
+    toTitle: r.to_title,
+    linkText: r.link_text,
+    linkType: r.link_type,
+    line: r.line
+  }));
+  return { page, links, backlinks };
+}
+function findOutdatedPages(db, repoPath, opts = {}) {
+  const pages = db.prepare("SELECT id, title, source_file, content_hash FROM wiki_pages WHERE team_id IS ?").all(opts.teamId ?? null);
+  const outdated = [];
+  for (const page of pages) {
+    const fullPath = join2(repoPath, page.source_file);
+    if (!existsSync2(fullPath)) {
+      outdated.push({
+        id: page.id,
+        title: page.title,
+        sourceFile: page.source_file,
+        reason: "file deleted"
+      });
+      continue;
+    }
+    try {
+      const content = readFileSync2(fullPath, "utf-8");
+      const hash = createHash2("sha256").update(content).digest("hex");
+      if (hash !== page.content_hash) {
+        outdated.push({
+          id: page.id,
+          title: page.title,
+          sourceFile: page.source_file,
+          reason: "content changed"
+        });
+      }
+    } catch {
+      outdated.push({
+        id: page.id,
+        title: page.title,
+        sourceFile: page.source_file,
+        reason: "read error"
+      });
+    }
+  }
+  return outdated;
+}
+
+// src/sdk.ts
+var Memory = class {
+  storage;
+  embedder;
+  sessionKey;
+  redactSecrets;
+  constructor(opts) {
+    const dbPath = opts?.dbPath ?? join3(homedir(), ".local", "share", "remem-mcp", "memory.db");
+    this.storage = new SQLiteBackend(dbPath);
+    this.embedder = new LocalEmbedder();
+    this.sessionKey = opts?.sessionKey ?? process.env.TDAI_SESSION_KEY ?? createHash3("sha256").update(process.cwd()).digest("hex").slice(0, 16);
+    this.redactSecrets = opts?.redactSecrets ?? true;
+  }
+  /** Capture a memory entry. Returns the ID, or null if duplicate. */
+  async capture(content, type, tags = []) {
+    const { text: redactedContent } = this.redactSecrets ? redact(content) : { text: content };
+    const contentHash = createHash3("sha256").update(redactedContent).digest("hex");
+    const existing = await this.storage.findByContentHash(contentHash, this.sessionKey);
+    if (existing.length > 0) return null;
+    const id = generateId();
+    const entry = {
+      id,
+      sessionKey: this.sessionKey,
+      agentId: "sdk",
+      type,
+      content: redactedContent,
+      tags,
+      createdAt: Date.now()
+    };
+    await this.storage.put(entry);
+    try {
+      const embedding = await this.embedder.embed(redactedContent);
+      await this.storage.putVector(id, embedding);
+    } catch {
+    }
+    return id;
+  }
+  /** Recall relevant memory. */
+  async recall(query, opts) {
+    const limit = Math.min(opts?.limit ?? 10, 50);
+    const mode = opts?.mode ?? "hybrid";
+    let queryEmbedding = null;
+    if (mode === "hybrid" || mode === "vector") {
+      queryEmbedding = await this.embedder.embed(query);
+    }
+    return this.storage.search(query, queryEmbedding, {
+      sessionKey: this.sessionKey,
+      limit,
+      offset: 0,
+      mode
+    });
+  }
+  /** Search with filters. */
+  async search(query, opts) {
+    const limit = Math.min(opts?.limit ?? 20, 100);
+    const mode = opts?.mode ?? "hybrid";
+    let queryEmbedding = null;
+    if (mode === "hybrid" || mode === "vector") {
+      queryEmbedding = await this.embedder.embed(query);
+    }
+    return this.storage.search(query, queryEmbedding, {
+      limit,
+      offset: 0,
+      mode,
+      filters: opts?.filters
+    });
+  }
+  /** Delete a capture by ID. */
+  async forget(id) {
+    return this.storage.delete(id);
+  }
+  /** Create a handoff packet for the next agent session. */
+  async handoff(opts) {
+    const lines = [];
+    lines.push(`# Handoff: ${opts.task}`);
+    lines.push(`Status: ${opts.status}`);
+    lines.push(`Date: ${(/* @__PURE__ */ new Date()).toISOString()}`);
+    lines.push("");
+    lines.push("## Progress");
+    lines.push(opts.progress);
+    lines.push("");
+    if (opts.decisions && opts.decisions.length > 0) {
+      lines.push("## Decisions");
+      for (const d of opts.decisions) lines.push(`- ${d}`);
+      lines.push("");
+    }
+    if (opts.files && opts.files.length > 0) {
+      lines.push("## Files");
+      for (const f of opts.files) lines.push(`- ${f}`);
+      lines.push("");
+    }
+    if (opts.nextSteps && opts.nextSteps.length > 0) {
+      lines.push("## Next steps");
+      opts.nextSteps.forEach((s, i) => {
+        lines.push(`${i + 1}. ${s}`);
+      });
+      lines.push("");
+    }
+    const content = lines.join("\n");
+    const dedupPayload = JSON.stringify({
+      task: opts.task,
+      status: opts.status,
+      progress: opts.progress,
+      decisions: opts.decisions ?? [],
+      files: opts.files ?? [],
+      nextSteps: opts.nextSteps ?? []
+    });
+    const contentHash = createHash3("sha256").update(dedupPayload).digest("hex");
+    const existing = await this.storage.findByContentHash(contentHash, this.sessionKey);
+    if (existing.length > 0) return null;
+    const id = generateId();
+    const entry = {
+      id,
+      sessionKey: this.sessionKey,
+      agentId: "sdk",
+      type: "task",
+      content,
+      tags: ["handoff", `status:${opts.status}`],
+      createdAt: Date.now(),
+      metadata: {
+        handoff: true,
+        task: opts.task,
+        status: opts.status,
+        progress: opts.progress,
+        decisions: opts.decisions ?? [],
+        files: opts.files ?? [],
+        nextSteps: opts.nextSteps ?? []
+      },
+      contentHash
+    };
+    await this.storage.put(entry);
+    try {
+      const embedding = await this.embedder.embed(content);
+      await this.storage.putVector(id, embedding);
+    } catch {
+    }
+    return id;
+  }
+  /** Record an Architecture Decision Record (ADR). */
+  async adr(opts) {
+    const lines = [];
+    lines.push(`# ADR: ${opts.title}`);
+    lines.push(`Date: ${(/* @__PURE__ */ new Date()).toISOString()}`);
+    lines.push("");
+    lines.push("## Context");
+    lines.push(opts.context);
+    lines.push("");
+    lines.push("## Decision");
+    lines.push(opts.decision);
+    lines.push("");
+    const alternatives = Array.isArray(opts.alternatives) ? opts.alternatives : typeof opts.alternatives === "string" && opts.alternatives ? [opts.alternatives] : [];
+    if (alternatives.length > 0) {
+      lines.push("## Alternatives considered");
+      for (const alt of alternatives) lines.push(`- ${alt}`);
+      lines.push("");
+    }
+    if (opts.consequences) {
+      lines.push("## Consequences");
+      lines.push(opts.consequences);
+      lines.push("");
+    }
+    const content = lines.join("\n");
+    const dedupPayload = JSON.stringify({
+      title: opts.title,
+      context: opts.context,
+      decision: opts.decision,
+      alternatives,
+      consequences: opts.consequences ?? ""
+    });
+    const contentHash = createHash3("sha256").update(dedupPayload).digest("hex");
+    const existing = await this.storage.findByContentHash(contentHash, this.sessionKey);
+    if (existing.length > 0) return null;
+    const id = generateId();
+    const entry = {
+      id,
+      sessionKey: this.sessionKey,
+      agentId: "sdk",
+      type: "decision",
+      content,
+      tags: ["adr", ...opts.tags ?? []],
+      createdAt: Date.now(),
+      metadata: {
+        adr: true,
+        title: opts.title,
+        context: opts.context,
+        decision: opts.decision,
+        alternatives,
+        consequences: opts.consequences ?? ""
+      },
+      contentHash
+    };
+    await this.storage.put(entry);
+    try {
+      const embedding = await this.embedder.embed(content);
+      await this.storage.putVector(id, embedding);
+    } catch {
+    }
+    return id;
+  }
+  /** Close the database connection. */
+  close() {
+    this.storage.close();
+  }
+};
+
+export {
+  SQLiteBackend,
+  LocalEmbedder,
+  local_exports,
+  init_local,
+  redact,
+  ingestFile,
+  ingestDirectory,
+  searchWiki,
+  getWikiPage,
+  findOutdatedPages,
+  Memory
+};
+//# sourceMappingURL=chunk-34TEZ5U4.js.map