@context-vault/core 2.15.0 → 2.17.1

package/src/core/temporal.js

@@ -0,0 +1,146 @@
+/**
+ * Temporal shortcut resolver.
+ *
+ * Converts natural-language time expressions to ISO date strings.
+ * Fully pure — accepts an explicit `now` Date for deterministic testing.
+ *
+ * Supported shortcuts (case-insensitive, spaces or underscores):
+ *   today          → start of today (00:00:00 local midnight in UTC)
+ *   yesterday      → { since: start of yesterday, until: end of yesterday }
+ *   this_week      → start of current ISO week (Monday 00:00)
+ *   last_N_days    → N days ago (e.g. last_3_days, last 7 days)
+ *   last_N_weeks   → N weeks ago
+ *   last_N_months  → N calendar months ago (approximate: N × 30 days)
+ *
+ * Anything that doesn't match a shortcut is returned unchanged so that ISO
+ * date strings pass straight through without modification.
+ */
+
+const SHORTCUT_RE = /^last[_ ](\d+)[_ ](day|days|week|weeks|month|months)$/i;
+
+/**
+ * Start of today in UTC (i.e. the midnight boundary at which the local date begins,
+ * expressed as an ISO string). We operate in UTC throughout so tests are portable.
+ *
+ * @param {Date} now
+ * @returns {Date}
+ */
+function startOfToday(now) {
+  const d = new Date(now);
+  d.setUTCHours(0, 0, 0, 0);
+  return d;
+}
+
+/**
+ * Resolve a single temporal expression to one or two ISO date strings.
+ *
+ * @param {"since"|"until"} role  - Which parameter we are resolving.
+ * @param {string} value          - Raw parameter value from the caller.
+ * @param {Date} [now]            - Override for "now" (defaults to `new Date()`).
+ * @returns {string}              - Resolved ISO date string (or original value if unrecognised).
+ */
+export function resolveTemporalShortcut(role, value, now = new Date()) {
+  if (!value || typeof value !== "string") return value;
+
+  const trimmed = value.trim().toLowerCase().replace(/\s+/g, "_");
+
+  if (trimmed === "today") {
+    const start = startOfToday(now);
+    if (role === "until") {
+      // "until today" means up to end-of-today
+      const end = new Date(start);
+      end.setUTCDate(end.getUTCDate() + 1);
+      return end.toISOString();
+    }
+    return start.toISOString();
+  }
+
+  if (trimmed === "yesterday") {
+    const todayStart = startOfToday(now);
+    const yesterdayStart = new Date(todayStart);
+    yesterdayStart.setUTCDate(yesterdayStart.getUTCDate() - 1);
+    if (role === "since") return yesterdayStart.toISOString();
+    // role === "until": end of yesterday = start of today
+    return todayStart.toISOString();
+  }
+
+  if (trimmed === "this_week") {
+    // Monday 00:00 UTC of the current week
+    const todayStart = startOfToday(now);
+    const dayOfWeek = todayStart.getUTCDay(); // 0=Sun, 1=Mon, ..., 6=Sat
+    const daysFromMonday = (dayOfWeek + 6) % 7; // 0 on Monday
+    const monday = new Date(todayStart);
+    monday.setUTCDate(monday.getUTCDate() - daysFromMonday);
+    if (role === "since") return monday.toISOString();
+    // "until this_week" means up to now (end of today)
+    const endOfToday = new Date(todayStart);
+    endOfToday.setUTCDate(endOfToday.getUTCDate() + 1);
+    return endOfToday.toISOString();
+  }
+
+  if (trimmed === "this_month") {
+    const d = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), 1));
+    if (role === "since") return d.toISOString();
+    const endOfMonth = new Date(
+      Date.UTC(now.getUTCFullYear(), now.getUTCMonth() + 1, 1),
+    );
+    return endOfMonth.toISOString();
+  }
+
+  const m = SHORTCUT_RE.exec(trimmed);
+  if (m) {
+    const n = parseInt(m[1], 10);
+    const unit = m[2].replace(/s$/, ""); // normalise plural → singular
+    let ms;
+    if (unit === "day") {
+      ms = n * 86400000;
+    } else if (unit === "week") {
+      ms = n * 7 * 86400000;
+    } else {
+      // month → approximate as 30 days
+      ms = n * 30 * 86400000;
+    }
+    const target = new Date(now.getTime() - ms);
+    target.setUTCHours(0, 0, 0, 0);
+    return target.toISOString();
+  }
+
+  // Unrecognised — pass through unchanged (ISO dates, empty strings, etc.)
+  return value;
+}
+
+/**
+ * Resolve both `since` and `until` parameters, handling the special case where
+ * "yesterday" sets both bounds automatically when only `since` is specified.
+ *
+ * Returns `{ since, until }` with resolved ISO strings (or originals).
+ *
+ * @param {{ since?: string, until?: string }} params
+ * @param {Date} [now]
+ * @returns {{ since: string|undefined, until: string|undefined }}
+ */
+export function resolveTemporalParams(params, now = new Date()) {
+  let { since, until } = params;
+
+  // Special case: "yesterday" on `since` without an explicit `until`
+  // auto-fills `until` to the end of yesterday.
+  if (
+    since?.trim().toLowerCase() === "yesterday" &&
+    (until === undefined || until === null)
+  ) {
+    since = resolveTemporalShortcut("since", since, now);
+    until = resolveTemporalShortcut("until", "yesterday", now);
+    return { since, until };
+  }
+
+  return {
+    since:
+      since !== undefined
+        ? resolveTemporalShortcut("since", since, now)
+        : since,
+    until:
+      until !== undefined
+        ? resolveTemporalShortcut("until", until, now)
+        : until,
+  };
+}

package/src/index/db.js

@@ -42,7 +42,69 @@ function runTransaction(db, fn) {
   }
 }
 
-export const SCHEMA_DDL = `
+// Local-mode schema: no multi-tenancy or encryption columns.
+// Identity uniqueness is scoped to (kind, identity_key) — no user_id.
+export const LOCAL_SCHEMA_DDL = `
+  CREATE TABLE IF NOT EXISTS vault (
+    id              TEXT PRIMARY KEY,
+    kind            TEXT NOT NULL,
+    category        TEXT NOT NULL DEFAULT 'knowledge',
+    title           TEXT,
+    body            TEXT NOT NULL,
+    meta            TEXT,
+    tags            TEXT,
+    source          TEXT,
+    file_path       TEXT UNIQUE,
+    identity_key    TEXT,
+    expires_at      TEXT,
+    superseded_by   TEXT,
+    created_at      TEXT DEFAULT (datetime('now')),
+    updated_at      TEXT,
+    hit_count       INTEGER DEFAULT 0,
+    last_accessed_at TEXT,
+    source_files    TEXT,
+    tier            TEXT DEFAULT 'working' CHECK(tier IN ('ephemeral', 'working', 'durable')),
+    related_to      TEXT
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_vault_kind ON vault(kind);
+  CREATE INDEX IF NOT EXISTS idx_vault_category ON vault(category);
+  CREATE INDEX IF NOT EXISTS idx_vault_category_created ON vault(category, created_at DESC);
+  CREATE INDEX IF NOT EXISTS idx_vault_updated ON vault(updated_at DESC);
+  CREATE UNIQUE INDEX IF NOT EXISTS idx_vault_identity ON vault(kind, identity_key) WHERE identity_key IS NOT NULL AND category = 'entity';
+  CREATE INDEX IF NOT EXISTS idx_vault_superseded ON vault(superseded_by) WHERE superseded_by IS NOT NULL;
+  CREATE INDEX IF NOT EXISTS idx_vault_tier ON vault(tier);
+
+  -- Single FTS5 table
+  CREATE VIRTUAL TABLE IF NOT EXISTS vault_fts USING fts5(
+    title, body, tags, kind,
+    content='vault', content_rowid='rowid'
+  );
+
+  -- FTS sync triggers
+  CREATE TRIGGER IF NOT EXISTS vault_ai AFTER INSERT ON vault BEGIN
+    INSERT INTO vault_fts(rowid, title, body, tags, kind)
+      VALUES (new.rowid, new.title, new.body, new.tags, new.kind);
+  END;
+  CREATE TRIGGER IF NOT EXISTS vault_ad AFTER DELETE ON vault BEGIN
+    INSERT INTO vault_fts(vault_fts, rowid, title, body, tags, kind)
+      VALUES ('delete', old.rowid, old.title, old.body, old.tags, old.kind);
+  END;
+  CREATE TRIGGER IF NOT EXISTS vault_au AFTER UPDATE ON vault BEGIN
+    INSERT INTO vault_fts(vault_fts, rowid, title, body, tags, kind)
+      VALUES ('delete', old.rowid, old.title, old.body, old.tags, old.kind);
+    INSERT INTO vault_fts(rowid, title, body, tags, kind)
+      VALUES (new.rowid, new.title, new.body, new.tags, new.kind);
+  END;
+
+  -- Single vec table (384-dim float32 for all-MiniLM-L6-v2)
+  CREATE VIRTUAL TABLE IF NOT EXISTS vault_vec USING vec0(embedding float[384]);
+`;
+
+// Hosted-mode schema: adds multi-tenancy (user_id, team_id) and at-rest
+// encryption columns (body_encrypted, title_encrypted, meta_encrypted, iv).
+// Identity uniqueness is scoped to (user_id, kind, identity_key).
+export const HOSTED_SCHEMA_DDL = `
   CREATE TABLE IF NOT EXISTS vault (
     id              TEXT PRIMARY KEY,
     kind            TEXT NOT NULL,
@@ -67,7 +129,8 @@ export const SCHEMA_DDL = `
     hit_count       INTEGER DEFAULT 0,
     last_accessed_at TEXT,
     source_files    TEXT,
-    tier            TEXT DEFAULT 'working' CHECK(tier IN ('ephemeral', 'working', 'durable'))
+    tier            TEXT DEFAULT 'working' CHECK(tier IN ('ephemeral', 'working', 'durable')),
+    related_to      TEXT
   );
 
   CREATE INDEX IF NOT EXISTS idx_vault_kind ON vault(kind);
@@ -106,7 +169,13 @@ export const SCHEMA_DDL = `
   CREATE VIRTUAL TABLE IF NOT EXISTS vault_vec USING vec0(embedding float[384]);
 `;
 
-export async function initDatabase(dbPath) {
+// Backward-compatible alias — kept for external consumers that reference SCHEMA_DDL.
+export const SCHEMA_DDL = HOSTED_SCHEMA_DDL;
+
+// Current target schema version. Bump this on every migration.
+const CURRENT_VERSION = 14;
+
+export async function initDatabase(dbPath, { mode = "local" } = {}) {
   const sqliteVec = await loadSqliteVec();
 
   function createDb(path) {
@@ -121,6 +190,8 @@ export async function initDatabase(dbPath) {
     return db;
   }
 
+  const schemaDdl = mode === "hosted" ? HOSTED_SCHEMA_DDL : LOCAL_SCHEMA_DDL;
+
   const db = createDb(dbPath);
   const version = db.prepare("PRAGMA user_version").get().user_version;
 
@@ -155,14 +226,14 @@ export async function initDatabase(dbPath) {
     } catch {}
 
     const freshDb = createDb(dbPath);
-    freshDb.exec(SCHEMA_DDL);
-    freshDb.exec("PRAGMA user_version = 12");
+    freshDb.exec(schemaDdl);
+    freshDb.exec(`PRAGMA user_version = ${CURRENT_VERSION}`);
     return freshDb;
   }
 
   if (version < 5) {
-    db.exec(SCHEMA_DDL);
-    db.exec("PRAGMA user_version = 12");
+    db.exec(schemaDdl);
+    db.exec(`PRAGMA user_version = ${CURRENT_VERSION}`);
   } else if (version === 5) {
     // v5 -> v6 migration: add multi-tenancy + encryption columns
     // Wrapped in transaction with duplicate-column guards for idempotent retry
@@ -344,12 +415,108 @@ export async function initDatabase(dbPath) {
     });
   }
 
+  if (version >= 5 && version <= 12) {
+    // v12 -> v13 migration: add related_to column for graph linking
+    runTransaction(db, () => {
+      try {
+        db.exec(`ALTER TABLE vault ADD COLUMN related_to TEXT`);
+      } catch (e) {
+        if (!e.message.includes("duplicate column")) throw e;
+      }
+      db.exec("PRAGMA user_version = 13");
+    });
+  }
+
+  if (version >= 5 && version <= 13) {
+    // v13 -> v14 migration: separate local and hosted schemas.
+    // Local mode: drop the 6 hosted-only columns (user_id, team_id,
+    // body_encrypted, title_encrypted, meta_encrypted, iv) and rebuild
+    // the identity index without user_id.
+    // Hosted mode: no structural change — just bump version.
+    runTransaction(db, () => {
+      if (mode === "local") {
+        // Must drop indexes that reference the columns before dropping columns.
+        db.exec(`DROP INDEX IF EXISTS idx_vault_user`);
+        db.exec(`DROP INDEX IF EXISTS idx_vault_team`);
+        db.exec(`DROP INDEX IF EXISTS idx_vault_identity`);
+        const dropColumnSafe = (col) => {
+          try {
+            db.exec(`ALTER TABLE vault DROP COLUMN ${col}`);
+          } catch (e) {
+            // Column may not exist on older schemas that never had it added.
+            if (!e.message.includes("no such column")) throw e;
+          }
+        };
+        dropColumnSafe("user_id");
+        dropColumnSafe("team_id");
+        dropColumnSafe("body_encrypted");
+        dropColumnSafe("title_encrypted");
+        dropColumnSafe("meta_encrypted");
+        dropColumnSafe("iv");
+        // Recreate identity uniqueness index scoped to (kind, identity_key),
+        // restricted to entity-category entries only (knowledge/event entries
+        // with identity_key are informational and may duplicate).
+        db.exec(
+          `CREATE UNIQUE INDEX IF NOT EXISTS idx_vault_identity ON vault(kind, identity_key) WHERE identity_key IS NOT NULL AND category = 'entity'`,
+        );
+      }
+      db.exec(`PRAGMA user_version = ${CURRENT_VERSION}`);
+    });
+  }
+
   return db;
 }
 
-export function prepareStatements(db) {
+export function prepareStatements(db, mode = "local") {
   try {
+    if (mode === "local") {
+      // Local mode: no user_id, team_id, or encryption columns.
+      // insertEntry has 15 params (no user_id).
+      // getByIdentityKey and upsertByIdentityKey have no user_id WHERE clause.
+      return {
+        _mode: "local",
+        insertEntry: db.prepare(
+          `INSERT INTO vault (id, kind, category, title, body, meta, tags, source, file_path, identity_key, expires_at, created_at, updated_at, source_files, tier) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        ),
+        updateEntry: db.prepare(
+          `UPDATE vault SET title = ?, body = ?, meta = ?, tags = ?, source = ?, category = ?, identity_key = ?, expires_at = ?, updated_at = datetime('now') WHERE file_path = ?`,
+        ),
+        deleteEntry: db.prepare(`DELETE FROM vault WHERE id = ?`),
+        getRowid: db.prepare(`SELECT rowid FROM vault WHERE id = ?`),
+        getRowidByPath: db.prepare(
+          `SELECT rowid FROM vault WHERE file_path = ?`,
+        ),
+        getEntryById: db.prepare(`SELECT * FROM vault WHERE id = ?`),
+        getByIdentityKey: db.prepare(
+          `SELECT * FROM vault WHERE kind = ? AND identity_key = ?`,
+        ),
+        upsertByIdentityKey: db.prepare(
+          `UPDATE vault SET title = ?, body = ?, meta = ?, tags = ?, source = ?, category = ?, file_path = ?, expires_at = ?, source_files = ?, updated_at = datetime('now') WHERE kind = ? AND identity_key = ?`,
+        ),
+        updateSourceFiles: db.prepare(
+          `UPDATE vault SET source_files = ? WHERE id = ?`,
+        ),
+        updateRelatedTo: db.prepare(
+          `UPDATE vault SET related_to = ? WHERE id = ?`,
+        ),
+        insertVecStmt: db.prepare(
+          `INSERT INTO vault_vec (rowid, embedding) VALUES (?, ?)`,
+        ),
+        deleteVecStmt: db.prepare(`DELETE FROM vault_vec WHERE rowid = ?`),
+        updateSupersededBy: db.prepare(
+          `UPDATE vault SET superseded_by = ? WHERE id = ?`,
+        ),
+        clearSupersededByRef: db.prepare(
+          `UPDATE vault SET superseded_by = NULL WHERE superseded_by = ?`,
+        ),
+      };
+    }
+
+    // Hosted mode: full schema with user_id scoping and encryption support.
+    // insertEntry has 16 params (includes user_id).
+    // getByIdentityKey and upsertByIdentityKey scope by user_id IS ?.
     return {
+      _mode: "hosted",
       insertEntry: db.prepare(
         `INSERT INTO vault (id, user_id, kind, category, title, body, meta, tags, source, file_path, identity_key, expires_at, created_at, updated_at, source_files, tier) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
       ),
@@ -372,6 +539,9 @@ export function prepareStatements(db) {
       updateSourceFiles: db.prepare(
         `UPDATE vault SET source_files = ? WHERE id = ?`,
       ),
+      updateRelatedTo: db.prepare(
+        `UPDATE vault SET related_to = ? WHERE id = ?`,
+      ),
       insertVecStmt: db.prepare(
         `INSERT INTO vault_vec (rowid, embedding) VALUES (?, ?)`,
       ),

package/src/index/index.js

@@ -66,37 +66,53 @@ export async function indexEntry(
   const cat = category || categoryFor(kind);
   const effectiveTier = tier || defaultTierFor(kind);
   const userIdVal = userId || null;
+  const isLocal = ctx.stmts._mode === "local";
 
   let wasUpdate = false;
 
-  // Entity upsert: check by (kind, identity_key, user_id) first
+  // Entity upsert: check by (kind, identity_key[, user_id]) first.
+  // Local mode omits user_id — all entries are user-agnostic.
   if (cat === "entity" && identity_key) {
-    const existing = ctx.stmts.getByIdentityKey.get(
-      kind,
-      identity_key,
-      userIdVal,
-    );
+    const existing = isLocal
+      ? ctx.stmts.getByIdentityKey.get(kind, identity_key)
+      : ctx.stmts.getByIdentityKey.get(kind, identity_key, userIdVal);
     if (existing) {
-      ctx.stmts.upsertByIdentityKey.run(
-        title || null,
-        body,
-        metaJson,
-        tagsJson,
-        source || "claude-code",
-        cat,
-        filePath,
-        expires_at || null,
-        sourceFilesJson,
-        kind,
-        identity_key,
-        userIdVal,
-      );
+      if (isLocal) {
+        ctx.stmts.upsertByIdentityKey.run(
+          title || null,
+          body,
+          metaJson,
+          tagsJson,
+          source || "claude-code",
+          cat,
+          filePath,
+          expires_at || null,
+          sourceFilesJson,
+          kind,
+          identity_key,
+        );
+      } else {
+        ctx.stmts.upsertByIdentityKey.run(
+          title || null,
+          body,
+          metaJson,
+          tagsJson,
+          source || "claude-code",
+          cat,
+          filePath,
+          expires_at || null,
+          sourceFilesJson,
+          kind,
+          identity_key,
+          userIdVal,
+        );
+      }
       wasUpdate = true;
     }
   }
 
   if (!wasUpdate) {
-    // Prepare encryption if ctx.encrypt is available
+    // Prepare encryption if ctx.encrypt is available (hosted mode only)
     let encrypted = null;
     if (ctx.encrypt) {
       encrypted = await ctx.encrypt({ title, body, meta });
@@ -104,7 +120,8 @@ export async function indexEntry(
 
     try {
       if (encrypted) {
-        // Encrypted insert: store preview in body column for FTS, full content in encrypted columns
+        // Hosted-mode encrypted insert: store preview in body for FTS,
+        // full content in encrypted columns.
         const bodyPreview = body.slice(0, 200);
         ctx.stmts.insertEntryEncrypted.run(
           id,
@@ -128,7 +145,27 @@ export async function indexEntry(
           sourceFilesJson,
           effectiveTier,
         );
+      } else if (isLocal) {
+        // Local mode: no user_id column — 15 params.
+        ctx.stmts.insertEntry.run(
+          id,
+          kind,
+          cat,
+          title || null,
+          body,
+          metaJson,
+          tagsJson,
+          source || "claude-code",
+          filePath,
+          identity_key || null,
+          expires_at || null,
+          createdAt,
+          createdAt,
+          sourceFilesJson,
+          effectiveTier,
+        );
       } else {
+        // Hosted mode without encryption: 16 params (includes user_id).
         ctx.stmts.insertEntry.run(
           id,
           userIdVal,
@@ -196,18 +233,20 @@ export async function indexEntry(
     );
   }
 
-  // Embeddings are always generated from plaintext (before encryption)
-  const embeddingText = [title, body].filter(Boolean).join(" ");
-  const embedding = await ctx.embed(embeddingText);
+  // Skip embedding generation for event entries — they are excluded from
+  // default semantic search and don't need vector representations
+  if (cat !== "event") {
+    const embeddingText = [title, body].filter(Boolean).join(" ");
+    const embedding = await ctx.embed(embeddingText);
 
-  // Upsert vec: delete old if exists, then insert new (skip if embedding unavailable)
-  if (embedding) {
-    try {
-      ctx.deleteVec(rowid);
-    } catch {
-      /* no-op if not found */
+    if (embedding) {
+      try {
+        ctx.deleteVec(rowid);
+      } catch {
+        /* no-op if not found */
+      }
+      ctx.insertVec(rowid, embedding);
     }
-    ctx.insertVec(rowid, embedding);
   }
 }
 
@@ -260,10 +299,14 @@ export async function reindex(ctx, opts = {}) {
 
   if (!existsSync(ctx.config.vaultDir)) return stats;
 
-  // Use INSERT OR IGNORE for reindex — handles files with duplicate frontmatter IDs
-  // user_id is NULL for reindex (always local mode)
+  // Use INSERT OR IGNORE for reindex — handles files with duplicate frontmatter IDs.
+  // Local mode: no user_id column (15 params).
+  // Hosted mode: user_id is NULL for file-sourced entries (14 params, NULL literal).
+  const isLocalReindex = ctx.stmts._mode === "local";
   const upsertEntry = ctx.db.prepare(
-    `INSERT OR IGNORE INTO vault (id, user_id, kind, category, title, body, meta, tags, source, file_path, identity_key, expires_at, created_at, updated_at) VALUES (?, NULL, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    isLocalReindex
+      ? `INSERT OR IGNORE INTO vault (id, kind, category, title, body, meta, tags, source, file_path, identity_key, expires_at, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+      : `INSERT OR IGNORE INTO vault (id, user_id, kind, category, title, body, meta, tags, source, file_path, identity_key, expires_at, created_at, updated_at) VALUES (?, NULL, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
   );
 
   // Auto-discover kind directories, supporting both:
@@ -315,7 +358,7 @@ export async function reindex(ctx, opts = {}) {
       // P3: Fetch all mutable fields for change detection
       const dbRows = ctx.db
         .prepare(
-          "SELECT id, file_path, body, title, tags, meta FROM vault WHERE kind = ?",
+          "SELECT id, file_path, body, title, tags, meta, related_to FROM vault WHERE kind = ?",
         )
         .all(kind);
       const dbByPath = new Map(dbRows.map((r) => [r.file_path, r]));
@@ -341,6 +384,12 @@ export async function reindex(ctx, opts = {}) {
         // Extract identity_key and expires_at from frontmatter
         const identity_key = fmMeta.identity_key || null;
         const expires_at = fmMeta.expires_at || null;
+        const related_to = Array.isArray(fmMeta.related_to)
+          ? fmMeta.related_to
+          : null;
+        const relatedToJson = related_to?.length
+          ? JSON.stringify(related_to)
+          : null;
 
         // Derive folder from disk location (source of truth)
         const meta = { ...(parsed.meta || {}) };
@@ -370,15 +419,20 @@ export async function reindex(ctx, opts = {}) {
             fmMeta.updated || created,
           );
           if (result.changes > 0) {
-            const rowidResult = ctx.stmts.getRowid.get(id);
-            if (rowidResult?.rowid) {
-              const embeddingText = [parsed.title, parsed.body]
-                .filter(Boolean)
-                .join(" ");
-              pendingEmbeds.push({
-                rowid: rowidResult.rowid,
-                text: embeddingText,
-              });
+            if (relatedToJson && ctx.stmts.updateRelatedTo) {
+              ctx.stmts.updateRelatedTo.run(relatedToJson, id);
+            }
+            if (category !== "event") {
+              const rowidResult = ctx.stmts.getRowid.get(id);
+              if (rowidResult?.rowid) {
+                const embeddingText = [parsed.title, parsed.body]
+                  .filter(Boolean)
+                  .join(" ");
+                pendingEmbeds.push({
+                  rowid: rowidResult.rowid,
+                  text: embeddingText,
+                });
+              }
             }
             stats.added++;
           } else {
@@ -392,8 +446,16 @@ export async function reindex(ctx, opts = {}) {
           const bodyChanged = existing.body !== parsed.body;
           const tagsChanged = tagsJson !== (existing.tags || null);
           const metaChanged = metaJson !== (existing.meta || null);
-
-          if (bodyChanged || titleChanged || tagsChanged || metaChanged) {
+          const relatedToChanged =
+            relatedToJson !== (existing.related_to || null);
+
+          if (
+            bodyChanged ||
+            titleChanged ||
+            tagsChanged ||
+            metaChanged ||
+            relatedToChanged
+          ) {
             ctx.stmts.updateEntry.run(
               parsed.title || null,
               parsed.body,
@@ -405,9 +467,12 @@ export async function reindex(ctx, opts = {}) {
               expires_at,
               filePath,
             );
+            if (relatedToChanged && ctx.stmts.updateRelatedTo) {
+              ctx.stmts.updateRelatedTo.run(relatedToJson, existing.id);
+            }
 
             // Queue re-embed if title or body changed (vector ops deferred to Phase 2)
-            if (bodyChanged || titleChanged) {
+            if ((bodyChanged || titleChanged) && category !== "event") {
               const rowid = ctx.stmts.getRowid.get(existing.id)?.rowid;
               if (rowid) {
                 const embeddingText = [parsed.title, parsed.body]

package/src/index.js

@@ -29,6 +29,11 @@ export {
   parseEntryFromMarkdown,
 } from "./core/frontmatter.js";
 export { gatherVaultStatus } from "./core/status.js";
+export {
+  PLURAL_TO_SINGULAR,
+  planMigration,
+  executeMigration,
+} from "./core/migrate-dirs.js";
 
 // Capture layer
 export {