agenr 0.12.1 → 0.12.2

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # Changelog
 
+## [0.12.2] - 2026-03-22
+
+### Recall Scoping Fixes
+
+- **Wildcard project passthrough.** `project: "*"` no longer gets silently dropped to `undefined` during recall request building. The wildcard marker now flows through the full stack to `hasWildcardProjectOverride` in `prepareRecallInputs`, enabling true cross-project recall.
+- **Default project fallback for unscoped recall.** When an agent calls `agenr_recall` without an explicit `project`, the session's default project is now used as a `universal_first` hint — searching the default project first with null-project fallback. Previously, unscoped recall defaulted to null-project-only entries, silently returning near-empty results for project-heavy corpora.
+- **Wildcard default when no project context.** When neither an explicit project nor a session default is available, unscoped recall now defaults to wildcard (`*`) cross-project search instead of null-project-only.
+
+### Browse Recall
+
+- **Temporal proximity rebalancing.** Browse mode recall now prioritizes temporal proximity over importance with a diversity pass, better surfacing recent entries during temporal exploration.
+- **Removed default 1d since window.** Browse mode no longer applies a default 1-day `since` window, allowing full temporal exploration of the corpus.
+
+### Update & Retire Improvements
+
+- **Expiry changes via `agenr_update`.** The update tool now supports changing an entry's expiry tier (`core` → `permanent`, etc.) without retiring and re-creating it. Entry history (confirmations, recall count, created_at) is preserved.
+- **Subject selectors for update and retire.** Both `agenr_update` and `agenr_retire` now accept `subject` as an alternative to `entry_id`. Subject matching is case-insensitive exact match; when multiple entries share a subject, the most recent is targeted.
+- **Agent action replay.** Retire and update operations now support recall target hints for agent action replay workflows.
+
+### Maintenance
+
+- **Vector integrity detection.** New `vector-integrity` maintain task detects and repairs drift between the vector shadow table and the entries table.
+
 ## [0.12.1] - 2026-03-21
 
 ### Post-Ingest Quality Fixes

package/README.md

@@ -162,7 +162,7 @@ agenr recall "package manager"
    tags: tooling, package-manager
 ```
 
-Recall supports date range queries (`--since 14d --until 7d`), temporal browse mode (`--browse --since 1d`), and around-date targeting (`--around 2026-02-15 --around-radius 14`) to rank entries by distance from a specific date.
+Recall supports date range queries (`--since 14d --until 7d`), temporal browse mode (`--browse --since 1d`), and around-date targeting (`--around 2026-02-15 --around-radius 14`) to rank entries primarily by distance from a specific date with importance used as a secondary tiebreaker.
 
 ### Cross-session Handoff
 
@@ -257,7 +257,7 @@ This exposes four MCP tools: `agenr_recall`, `agenr_extract`, `agenr_retire`, an
 | `agenr store [files...]` | Store entries with semantic dedup |
 | `agenr recall [query]` | Semantic + memory-aware recall. Use `--since`/`--until` for date ranges, `--around` for target-date ranking, `--browse` for temporal mode. |
 | `agenr retire [subject]` | Retire a stale entry (hidden, not deleted). Match by subject or `--id`. |
-| `agenr update --id <id> --importance <n>` | Update an entry in place. Currently supports importance only. |
+| `agenr update --id <id> [--importance <n>] [--expiry <level>]` | Update mutable entry metadata in place. Supports importance and expiry; pass at least one. |
 | `agenr watch [file]` | Live-watch files/directories, auto-extract knowledge |
 | `agenr watcher install` | Install background watch daemon (macOS launchd) |
 | `agenr watcher status` | Show daemon status (running/stopped, pid, watched file, recent logs) |

package/dist/chunk-CUCVRI3K.js

@@ -0,0 +1,34 @@
+// src/domain/watcher-demotion.ts
+var WATCHER_DEMOTED_TAG = "watcher-demoted";
+var DEFAULT_OPENCLAW_WATCHER_DEMOTION_IMPORTANCE_CAP = 4;
+var DEFAULT_OPENCLAW_WATCHER_DEMOTION_TTL_DAYS = 30;
+function clampInteger(value, floor, fallback) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return fallback;
+  }
+  return Math.max(floor, Math.floor(value));
+}
+function resolveOpenClawWatcherDemotionConfig(config) {
+  const watcherConfig = config?.watcher?.openclawDemotion;
+  return {
+    enabled: watcherConfig?.enabled !== false,
+    importanceCap: Math.min(
+      10,
+      clampInteger(
+        watcherConfig?.importanceCap,
+        1,
+        DEFAULT_OPENCLAW_WATCHER_DEMOTION_IMPORTANCE_CAP
+      )
+    ),
+    ttlDays: clampInteger(
+      watcherConfig?.ttlDays,
+      1,
+      DEFAULT_OPENCLAW_WATCHER_DEMOTION_TTL_DAYS
+    )
+  };
+}
+
+export {
+  WATCHER_DEMOTED_TAG,
+  resolveOpenClawWatcherDemotionConfig
+};

package/dist/{chunk-PLIY7PBU.js → chunk-D3DYUJKW.js}

@@ -47,7 +47,7 @@ import {
   createAppRuntime,
   readAppDbSession,
   resolveDefaultAppRuntimeDeps
-} from "./chunk-BD3SRNYZ.js";
+} from "./chunk-YFOFO2FC.js";
 import {
   mapStoredEntry,
   shapeRecallText
@@ -65,7 +65,7 @@ import {
 import {
   createLogger,
   walCheckpoint
-} from "./chunk-4GIJ227W.js";
+} from "./chunk-HMBONTF3.js";
 import {
   DEFAULT_TASK_MODEL,
   resolveClaimExtractionBatchSize,
@@ -948,6 +948,37 @@ async function buildEntityRegistry(db) {
   return buildEntityRegistryFromRows(rows);
 }
 
+// src/utils/expiry.ts
+var EXPIRY_SET = new Set(EXPIRY_LEVELS);
+var EXPIRY_PRIORITY = {
+  temporary: 0,
+  permanent: 1,
+  core: 2
+};
+function normalizeExpiry(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const normalized = value.trim().toLowerCase();
+  if (!normalized) {
+    return void 0;
+  }
+  return EXPIRY_SET.has(normalized) ? normalized : void 0;
+}
+function coerceExpiry(value, fallback = "temporary") {
+  return normalizeExpiry(value) ?? fallback;
+}
+function resolveHigherExpiry(a, b) {
+  return EXPIRY_PRIORITY[a] >= EXPIRY_PRIORITY[b] ? a : b;
+}
+function resolveHighestExpiry(expiries) {
+  let highest = "temporary";
+  for (const expiry of expiries) {
+    highest = resolveHigherExpiry(highest, expiry);
+  }
+  return highest;
+}
+
 // src/db/lockfile.ts
 import fs from "fs";
 import os from "os";
@@ -2301,37 +2332,6 @@ function evaluateConflictsForRejection(conflicts, newEntry, config) {
   };
 }
 
-// src/utils/expiry.ts
-var EXPIRY_SET = new Set(EXPIRY_LEVELS);
-var EXPIRY_PRIORITY = {
-  temporary: 0,
-  permanent: 1,
-  core: 2
-};
-function normalizeExpiry(value) {
-  if (typeof value !== "string") {
-    return void 0;
-  }
-  const normalized = value.trim().toLowerCase();
-  if (!normalized) {
-    return void 0;
-  }
-  return EXPIRY_SET.has(normalized) ? normalized : void 0;
-}
-function coerceExpiry(value, fallback = "temporary") {
-  return normalizeExpiry(value) ?? fallback;
-}
-function resolveHigherExpiry(a, b) {
-  return EXPIRY_PRIORITY[a] >= EXPIRY_PRIORITY[b] ? a : b;
-}
-function resolveHighestExpiry(expiries) {
-  let highest = "temporary";
-  for (const expiry of expiries) {
-    highest = resolveHigherExpiry(highest, expiry);
-  }
-  return highest;
-}
-
 // src/memory/store/mutations.ts
 async function applyEntryMutation(repository, processed, embedFn, apiKey, cache, config, options) {
   const mutation = processed.mutation;
@@ -5598,6 +5598,47 @@ async function finalizeRecallResults(params) {
   return results;
 }
 
+// src/domain/recall/browse-selection.ts
+var DEFAULT_BROWSE_DIVERSITY_TARGET = 4;
+function normalizeEntryType(result) {
+  const rawType = result.entry.type;
+  return typeof rawType === "string" ? rawType.trim().toLowerCase() : "";
+}
+function diversifyBrowseResults(results, limit, diversityTarget = DEFAULT_BROWSE_DIVERSITY_TARGET) {
+  const normalizedLimit = Math.max(0, Math.floor(limit));
+  if (normalizedLimit === 0 || results.length === 0) {
+    return [];
+  }
+  const normalizedDiversityTarget = Math.max(0, Math.floor(diversityTarget));
+  const seedTarget = Math.min(normalizedLimit, normalizedDiversityTarget);
+  const selected = [];
+  const selectedIds = /* @__PURE__ */ new Set();
+  const admittedTypes = /* @__PURE__ */ new Set();
+  for (const result of results) {
+    if (selected.length >= seedTarget) {
+      break;
+    }
+    const normalizedType = normalizeEntryType(result);
+    if (!normalizedType || admittedTypes.has(normalizedType)) {
+      continue;
+    }
+    selected.push(result);
+    selectedIds.add(result.entry.id);
+    admittedTypes.add(normalizedType);
+  }
+  for (const result of results) {
+    if (selected.length >= normalizedLimit) {
+      break;
+    }
+    if (selectedIds.has(result.entry.id)) {
+      continue;
+    }
+    selected.push(result);
+    selectedIds.add(result.entry.id);
+  }
+  return selected;
+}
+
 // src/domain/recall/lexical.ts
 var STOP_TOKENS = /* @__PURE__ */ new Set([
   "a",
@@ -5754,6 +5795,8 @@ var DEFAULT_RECALL_SATURATION = 10;
 var DEFAULT_WARM_START_THRESHOLD = 3;
 var DEFAULT_SYNTHETIC_FLOOR = 0.1;
 var DEFAULT_AGENT_SOURCE_BONUS = 0.05;
+var BROWSE_RECENCY_WEIGHT = 0.8;
+var BROWSE_IMPORTANCE_WEIGHT = 0.2;
 var MISSING_RECALL_DAYS = 99999;
 var EMPTY_RECALL_METRICS = {
   totalCount: 0,
@@ -5878,7 +5921,9 @@ function browseRecencyFactor(entry, now, aroundDate, aroundRadius = DEFAULT_AROU
   return resolveRecallRecency(entry, now, aroundDate, aroundRadius);
 }
 function scoreBrowseEntry(entry, now, aroundDate, aroundRadius = DEFAULT_AROUND_RADIUS_DAYS) {
-  return clamp01((browseRecencyFactor(entry, now, aroundDate, aroundRadius) + importanceScore(entry.importance)) / 2);
+  const recency2 = browseRecencyFactor(entry, now, aroundDate, aroundRadius);
+  const importance = importanceScore(entry.importance);
+  return clamp01(recency2 * BROWSE_RECENCY_WEIGHT + importance * BROWSE_IMPORTANCE_WEIGHT);
 }
 function scoreSessionEntry(entry, effectiveNow, freshnessNow, metricsMap, aroundDate, aroundRadius = DEFAULT_AROUND_RADIUS_DAYS, config) {
   return scoreEntryWithBreakdown(
@@ -6261,8 +6306,21 @@ async function fetchBrowseCandidates(params) {
     whereClauses.push("platform = ?");
     args.push(params.query.platform);
   }
-  args.push(params.limit);
   const whereClause = whereClauses.length > 0 ? "WHERE " + whereClauses.join(" AND ") : "";
+  const orderBy = params.aroundDate ? `
+      ORDER BY
+        ABS(julianday(created_at) - julianday(?)) ASC,
+        importance DESC,
+        created_at DESC
+    ` : `
+      ORDER BY
+        created_at DESC,
+        importance DESC
+    `;
+  if (params.aroundDate) {
+    args.push(params.aroundDate.toISOString());
+  }
+  args.push(params.limit);
   const result = await params.db.execute({
     sql: `
       SELECT
@@ -6270,10 +6328,10 @@ async function fetchBrowseCandidates(params) {
       FROM entries
       ${whereClause}
       -- SQL pre-sort is a best-effort approximation only.
-      -- Final order is determined by scoreBrowseEntry() (importance * recency decay)
-      -- which re-sorts post-fetch. The over-fetch buffer (limit*3, min 50)
+      -- Final order is determined by recency-first browse scoring and a post-score
+      -- diversity pass. The over-fetch buffer (limit*3, min 50)
       -- ensures the final top-N are present in the candidate pool.
-      ORDER BY importance DESC, created_at DESC
+      ${orderBy}
       LIMIT ?
     `,
     args
@@ -6499,6 +6557,7 @@ async function recallBrowseMode(params) {
     query: browseQuery,
     limit: browseLimit,
     now: params.now,
+    aroundDate: params.prepared.temporal.aroundDate,
     projectFilter: params.prepared.scope.resolution.primaryFilter
   });
   const filtered = browseCandidates.filter(
@@ -6519,7 +6578,11 @@ async function recallBrowseMode(params) {
     aroundRadiusDays: params.prepared.temporal.aroundRadiusDays
   });
   scored.sort((left, right) => right.score - left.score);
-  return scored.slice(0, requestedLimit);
+  const results = diversifyBrowseResults(scored, requestedLimit, DEFAULT_BROWSE_DIVERSITY_TARGET);
+  if (params.trace) {
+    params.trace.finalResultIds = results.map((result) => result.entry.subject ?? result.entry.id);
+  }
+  return results;
 }
 async function retrieveCandidates(params) {
   if (!params.prepared.retrievalSearchText) {
@@ -6924,11 +6987,12 @@ function resolvePreparedRecallScope(query, normalizedQuery) {
   const explicitWildcardProject = hasWildcardProjectOverride(query.project);
   const explicitProjects = explicitWildcardProject ? [] : parseProjectList(query.project);
   const explicitExcludedProjects = parseProjectList(query.excludeProject);
-  const inferredProjectHints = deriveRecallProjectScopeHints({
+  const inferredProjectHints = explicitWildcardProject ? [] : deriveRecallProjectScopeHints({
     queryText: normalizedQuery?.searchText ?? query.text ?? "",
     explicitProjects
   });
-  const projectHints = explicitProjects.length > 0 ? explicitProjects : inferredProjectHints;
+  const callerProjectHints = explicitProjects.length > 0 || explicitWildcardProject ? [] : parseProjectList(query.projectHints).filter((projectHint) => projectHint !== "*");
+  const projectHints = explicitProjects.length > 0 ? explicitProjects : Array.from(/* @__PURE__ */ new Set([...inferredProjectHints, ...callerProjectHints]));
   const intent = projectHints.length > 0 ? "project" : normalizedQuery?.scopeIntent ?? "ambiguous";
   if (query.universalOnly === true) {
     return {

package/dist/{chunk-4GIJ227W.js → chunk-HMBONTF3.js}

@@ -650,6 +650,195 @@ var CREATE_INDEX_STATEMENTS = [
   "CREATE UNIQUE INDEX IF NOT EXISTS idx_ingest_log_file_hash ON ingest_log(file_path, content_hash)"
 ];
 
+// src/db/vector-index.ts
+var ACTIVE_EMBEDDED_WHERE_SQL = `
+  embedding IS NOT NULL
+    AND retired = 0
+    AND superseded_by IS NULL
+`;
+var SELF_UPDATE_ACTIVE_EMBEDDINGS_SQL = `
+  UPDATE entries
+  SET embedding = embedding
+  WHERE ${ACTIVE_EMBEDDED_WHERE_SQL}
+`;
+var TEMP_REPAIR_TABLE = "_vec_repair";
+var REPAIR_CHUNK_SIZE = 100;
+function toNumber(value) {
+  if (typeof value === "number") {
+    return value;
+  }
+  if (typeof value === "bigint") {
+    return Number(value);
+  }
+  if (typeof value === "string" && value.trim()) {
+    return Number(value);
+  }
+  return Number.NaN;
+}
+function toFiniteCount(value) {
+  const numeric = toNumber(value);
+  if (!Number.isFinite(numeric)) {
+    return 0;
+  }
+  return Math.max(0, Math.trunc(numeric));
+}
+function normalizeRowid(value) {
+  const numeric = toNumber(value);
+  if (!Number.isFinite(numeric)) {
+    return null;
+  }
+  const rowid = Math.trunc(numeric);
+  return rowid > 0 ? rowid : null;
+}
+function formatShadowMismatch(stats) {
+  const details = [`active=${stats.embeddingCount}`, `shadow=${stats.shadowCount}`];
+  if (stats.missingRowids.length > 0) {
+    details.push(`missing=${stats.missingRowids.length}`);
+  }
+  return details.join(", ");
+}
+async function rollbackQuietly(db) {
+  try {
+    await db.execute("ROLLBACK");
+  } catch {
+  }
+}
+async function dropRepairTableQuietly(db) {
+  try {
+    await db.execute(`DROP TABLE IF EXISTS ${TEMP_REPAIR_TABLE}`);
+  } catch {
+  }
+}
+async function repairMissingRowids(db, missingRowids) {
+  if (missingRowids.length === 0) {
+    return;
+  }
+  await db.execute(`DROP TABLE IF EXISTS ${TEMP_REPAIR_TABLE}`);
+  await db.execute(`
+    CREATE TEMP TABLE ${TEMP_REPAIR_TABLE} (
+      rid INTEGER PRIMARY KEY,
+      emb BLOB NOT NULL
+    )
+  `);
+  try {
+    for (let index = 0; index < missingRowids.length; index += REPAIR_CHUNK_SIZE) {
+      const chunk = missingRowids.slice(index, index + REPAIR_CHUNK_SIZE);
+      if (chunk.length === 0) {
+        continue;
+      }
+      const placeholders = chunk.map(() => "?").join(", ");
+      await db.execute(`DELETE FROM ${TEMP_REPAIR_TABLE}`);
+      await db.execute({
+        sql: `
+          INSERT INTO ${TEMP_REPAIR_TABLE} (rid, emb)
+          SELECT rowid, embedding
+          FROM entries
+          WHERE rowid IN (${placeholders})
+        `,
+        args: chunk
+      });
+      await db.execute({
+        sql: `
+          UPDATE entries
+          SET embedding = NULL
+          WHERE rowid IN (${placeholders})
+        `,
+        args: chunk
+      });
+      await db.execute({
+        sql: `
+          UPDATE entries
+          SET embedding = (
+            SELECT emb
+            FROM ${TEMP_REPAIR_TABLE}
+            WHERE rid = entries.rowid
+          )
+          WHERE rowid IN (${placeholders})
+        `,
+        args: chunk
+      });
+    }
+  } finally {
+    await dropRepairTableQuietly(db);
+  }
+}
+async function getVectorIndexShadowStats(db) {
+  const countsResult = await db.execute(`
+    SELECT
+      (SELECT COUNT(*) FROM entries WHERE ${ACTIVE_EMBEDDED_WHERE_SQL}) AS embedding_count,
+      (SELECT COUNT(*) FROM idx_entries_embedding_shadow) AS shadow_count
+  `);
+  const countsRow = countsResult.rows[0];
+  const embeddingCount = toFiniteCount(countsRow?.embedding_count);
+  const shadowCount = toFiniteCount(countsRow?.shadow_count);
+  const missingResult = await db.execute(`
+    SELECT e.rowid AS rowid
+    FROM entries AS e
+    LEFT JOIN idx_entries_embedding_shadow AS s
+      ON s.index_key = e.rowid
+    WHERE e.embedding IS NOT NULL
+      AND e.retired = 0
+      AND e.superseded_by IS NULL
+      AND s.index_key IS NULL
+    ORDER BY e.rowid ASC
+  `);
+  const missingRowids = missingResult.rows.map((row) => normalizeRowid(row.rowid)).filter((rowid) => rowid !== null);
+  return {
+    embeddingCount,
+    shadowCount,
+    missingRowids
+  };
+}
+async function rebuildVectorIndex(db, options) {
+  const start = Date.now();
+  const onLog = options?.onLog ?? (() => void 0);
+  await db.execute("BEGIN IMMEDIATE");
+  try {
+    await db.execute("DROP INDEX IF EXISTS idx_entries_embedding");
+    await db.execute(CREATE_IDX_ENTRIES_EMBEDDING_SQL);
+    await db.execute(SELF_UPDATE_ACTIVE_EMBEDDINGS_SQL);
+    const beforeRepair = await getVectorIndexShadowStats(db);
+    let repairedCount = 0;
+    if (beforeRepair.missingRowids.length > 0) {
+      repairedCount = beforeRepair.missingRowids.length;
+      onLog(`[vector-index] repairing ${repairedCount} entries missing from shadow table`);
+      await repairMissingRowids(db, beforeRepair.missingRowids);
+    }
+    const afterRepair = await getVectorIndexShadowStats(db);
+    if (afterRepair.missingRowids.length > 0 || afterRepair.shadowCount !== afterRepair.embeddingCount) {
+      throw new Error(`Vector index shadow table desynced after rebuild (${formatShadowMismatch(afterRepair)})`);
+    }
+    if (afterRepair.embeddingCount > 0) {
+      const verify = await db.execute(`
+        SELECT count(*) AS count
+        FROM vector_top_k(
+          'idx_entries_embedding',
+          (SELECT embedding FROM entries WHERE ${ACTIVE_EMBEDDED_WHERE_SQL} LIMIT 1),
+          1
+        )
+      `);
+      const verifyCount = toFiniteCount(verify.rows[0]?.count);
+      if (verifyCount !== 1) {
+        throw new Error(`Vector index rebuild verification failed (expected 1, got ${verifyCount})`);
+      }
+    }
+    await db.execute("COMMIT");
+    const durationMs = Date.now() - start;
+    onLog(
+      `[vector-index] rebuilt for ${afterRepair.embeddingCount} entries (${afterRepair.shadowCount} shadow rows, ${repairedCount} repaired, ${durationMs}ms)`
+    );
+    return {
+      embeddingCount: afterRepair.embeddingCount,
+      shadowCount: afterRepair.shadowCount,
+      repairedCount,
+      durationMs
+    };
+  } catch (error) {
+    await rollbackQuietly(db);
+    throw error;
+  }
+}
+
 // src/db/schema/fts.ts
 async function rebuildEntriesFts(db) {
   await db.execute("INSERT INTO entries_fts(entries_fts) VALUES('delete-all')");
@@ -696,31 +885,16 @@ async function rebuildFtsAndTriggers(db) {
     throw error;
   }
 }
-async function rebuildVectorIndex(db) {
+async function rebuildVectorIndex2(db) {
   try {
     await db.execute("REINDEX idx_entries_embedding");
-    return;
-  } catch {
-  }
-  await db.execute("BEGIN IMMEDIATE");
-  try {
-    await db.execute("DROP INDEX IF EXISTS idx_entries_embedding");
-    await db.execute(CREATE_IDX_ENTRIES_EMBEDDING_SQL);
-    await db.execute(`
-      UPDATE entries
-      SET embedding = embedding
-      WHERE embedding IS NOT NULL
-        AND retired = 0
-        AND superseded_by IS NULL
-    `);
-    await db.execute("COMMIT");
-  } catch (fallbackError) {
-    try {
-      await db.execute("ROLLBACK");
-    } catch {
+    const stats = await getVectorIndexShadowStats(db);
+    if (stats.shadowCount === stats.embeddingCount && stats.missingRowids.length === 0) {
+      return;
     }
-    throw fallbackError;
+  } catch {
   }
+  await rebuildVectorIndex(db);
 }
 async function setBulkIngestMeta(db, phase) {
   await db.execute({
@@ -1278,15 +1452,10 @@ async function repairVectorIndexIfNeeded(client) {
     if (probeCount > 0) {
       return;
     }
-    await client.execute("DROP INDEX IF EXISTS idx_entries_embedding");
-    await client.execute(CREATE_IDX_ENTRIES_EMBEDDING_SQL);
-    await client.execute(`
-      UPDATE entries
-      SET embedding = embedding
-      WHERE embedding IS NOT NULL
-        AND retired = 0
-        AND superseded_by IS NULL
-    `);
+  } catch {
+  }
+  try {
+    await rebuildVectorIndex(client);
   } catch {
   }
 }
@@ -1487,7 +1656,7 @@ async function checkAndRecoverBulkIngest(client) {
       }
     }
     if (indexCount < 1) {
-      await rebuildVectorIndex(client);
+      await rebuildVectorIndex2(client);
     }
     try {
       const integrityResult = await client.execute("PRAGMA integrity_check");
@@ -1639,10 +1808,11 @@ function closeDb(client) {
 export {
   APP_VERSION,
   createLogger,
-  CREATE_IDX_ENTRIES_EMBEDDING_SQL,
+  getVectorIndexShadowStats,
+  rebuildVectorIndex,
   dropFtsTriggersAndIndex,
   rebuildFtsAndTriggers,
-  rebuildVectorIndex,
+  rebuildVectorIndex2,
   setBulkIngestMeta,
   clearBulkIngestMeta,
   resetDb,

package/dist/{chunk-K5QPCUEW.js → chunk-L2CPAYHC.js}

@@ -11,7 +11,7 @@ import {
   resolveHigherExpiry,
   resolveHighestExpiry,
   runSimpleStream
-} from "./chunk-PLIY7PBU.js";
+} from "./chunk-D3DYUJKW.js";
 import {
   deleteCoRecallEdgesForEntryIds
 } from "./chunk-BXN5MMRG.js";
@@ -20,9 +20,6 @@ import {
   insertEntry,
   recordEntrySupport
 } from "./chunk-UNB2GHB2.js";
-import {
-  rebuildVectorIndex
-} from "./chunk-JQJNOQH5.js";
 import {
   KNOWLEDGE_TYPES,
   resolveConflictLog
@@ -30,7 +27,7 @@ import {
 import {
   isShutdownRequested,
   resolveDefaultAppRuntimeDeps
-} from "./chunk-BD3SRNYZ.js";
+} from "./chunk-YFOFO2FC.js";
 import {
   isRecord
 } from "./chunk-IVDSYJNR.js";
@@ -42,8 +39,9 @@ import {
 } from "./chunk-QDW77NBA.js";
 import {
   createLogger,
+  rebuildVectorIndex,
   walCheckpoint
-} from "./chunk-4GIJ227W.js";
+} from "./chunk-HMBONTF3.js";
 import {
   cosineSimilarity,
   mapBufferToVector
@@ -80,6 +78,7 @@ var FILTERABLE_TASKS = [
 ];
 var ALL_TASKS = [
   ...FILTERABLE_TASKS,
+  "vector-integrity",
   "snapshot"
 ];
 var CONFLICTS_LIMIT_DEFAULT = 25;
@@ -1377,6 +1376,9 @@ function buildMergeContext(cluster) {
     "Merge the provided related entries into one or more canonical entries.",
     "Only include information explicitly stated in the source entries. Do not infer or add details not present.",
     "Do not turn distinct structured identities, role distinctions, or changed durable values into one blended blob summary.",
+    "If entries describe different people, owners, locations, or other entities - even when they share a common topic - do not merge them into one entry. Split them into separate outputs.",
+    "For example, 'Mom has dogs X and Y in Texas' and 'Dad has dog Z in Colorado' must remain separate entries, not become 'Mom has dogs X, Y, and Z.'",
+    "If a source entry combines information about multiple distinct entities, split it into per-entity outputs rather than using the summary as justification to merge everything together.",
     "current_state, prior_state, and state_transition anchors must remain distinct. Split them into separate outputs when needed.",
     "If the source entries share structured claim metadata (subject_key, claim_predicate, claim_object), preserve those fields exactly in the merged output.",
     "Do not invent new structured claim metadata. Only include structured claim fields when they are shared across the source entries being merged.",