claude-mem-lite 2.88.0 → 2.90.0

package/install.mjs

@@ -10,8 +10,18 @@ import { createRequire } from 'node:module';
 
 const PROJECT_DIR = resolve(import.meta.dirname ?? dirname(fileURLToPath(import.meta.url)));
 const SETTINGS_PATH = join(homedir(), '.claude', 'settings.json');
+// Plugin CODE / install location — ALWAYS homedir-rooted. Claude Code's
+// settings.json + MCP registration bake ABSOLUTE paths to server.mjs / hooks here,
+// and env vars are per-shell (the MCP launcher won't reliably inherit
+// CLAUDE_MEM_DIR), so code must NOT follow the relocation env var.
 const DATA_DIR = join(homedir(), '.claude-mem-lite');
-const DB_PATH = join(DATA_DIR, 'claude-mem-lite.db');
+// User DATA location — DB, managed resources, registry DB, runtime/. Honors
+// CLAUDE_MEM_DIR exactly like schema.mjs DB_DIR so the installer WRITES data where
+// the runtime/data layer READS it (pre-fix: installer wrote homedir, runtime read
+// the relocated dir → preinstalled skills silently vanished, doctor read the wrong
+// DB). Equals DATA_DIR when CLAUDE_MEM_DIR is unset (the common case).
+const MEM_DATA_DIR = process.env.CLAUDE_MEM_DIR || DATA_DIR;
+const DB_PATH = join(MEM_DATA_DIR, 'claude-mem-lite.db');
 const OLD_DATA_DIR = join(homedir(), '.claude-mem');
 
 // Detect ephemeral context (npx) — files won't persist after exit
@@ -319,6 +329,8 @@ async function install() {
   }
 
   if (!existsSync(DATA_DIR)) mkdirSync(DATA_DIR, { recursive: true });
+  // Under relocation the DB/managed/runtime live here, not in the code dir — create it too.
+  if (!existsSync(MEM_DATA_DIR)) mkdirSync(MEM_DATA_DIR, { recursive: true });
 
   if (IS_DEV) {
     log('Dev mode — creating symlinks in ~/.claude-mem-lite/...');
@@ -675,7 +687,7 @@ async function install() {
   // "no such column: memory_session_id". Rename to a timestamped backup
   // so the new install creates a fresh v28 DB.
   try {
-    const r = migrateLegacyClaudeMemData(OLD_DATA_DIR, DATA_DIR);
+    const r = migrateLegacyClaudeMemData(OLD_DATA_DIR, MEM_DATA_DIR);
     if (r.action === 'backed-up') {
       ok(`Legacy ~/.claude-mem/ DB backed up to ${r.backupPath}`);
       log('New v28 DB will be created on first launch (legacy schema is incompatible).');
@@ -685,7 +697,7 @@ async function install() {
   }
 
   // 5b. Rename claude-mem.db → claude-mem-lite.db in same directory
-  const oldDbInDir = join(DATA_DIR, 'claude-mem.db');
+  const oldDbInDir = join(MEM_DATA_DIR, 'claude-mem.db');
   if (existsSync(oldDbInDir) && !existsSync(DB_PATH)) {
     renameSync(oldDbInDir, DB_PATH);
     for (const ext of ['-wal', '-shm']) {
@@ -714,7 +726,7 @@ async function install() {
       const resources = manifest.resources || [];
 
       if (resources.length > 0) {
-        const managedDir = join(DATA_DIR, 'managed');
+        const managedDir = join(MEM_DATA_DIR, 'managed');
 
         // 6a. Git shallow clone unique repos
         const repos = new Map();
@@ -805,7 +817,7 @@ async function install() {
 
         // 6b. Init registry DB and record preinstalled entries
         const { ensureRegistryDb } = await importFromInstall('registry.mjs');
-        const regDbPath = join(DATA_DIR, 'resource-registry.db');
+        const regDbPath = join(MEM_DATA_DIR, 'resource-registry.db');
         const rdb = ensureRegistryDb(regDbPath);
 
         const insertPre = rdb.prepare(`
@@ -853,7 +865,7 @@ async function install() {
         // 6d. Scan and index resources (fallback-only, Haiku indexing deferred to first run)
         log('  Scanning resources...');
         const { scanAllResources, diffResources } = await importFromInstall('registry-scanner.mjs');
-        const scanned = scanAllResources({ dataDir: DATA_DIR });
+        const scanned = scanAllResources({ dataDir: MEM_DATA_DIR });
 
         // Attach star counts and repo URLs
         for (const s of scanned) {
@@ -1063,15 +1075,26 @@ async function uninstall() {
 
   // 6. Purge data if requested
   if (flags.has('--purge')) {
-    const expectedPurgePath = join(homedir(), '.claude-mem-lite');
-    if (existsSync(DATA_DIR) && DATA_DIR === expectedPurgePath) {
+    const homeDir = join(homedir(), '.claude-mem-lite');
+    // Always remove the homedir code/install dir (guarded to the canonical path).
+    if (existsSync(DATA_DIR) && DATA_DIR === homeDir) {
       rmSync(DATA_DIR, { recursive: true, force: true });
       ok('Data purged (~/.claude-mem-lite/)');
     } else if (existsSync(DATA_DIR)) {
       fail('DATA_DIR path mismatch, refusing to purge for safety: ' + DATA_DIR);
     }
+    // Also remove the relocated data dir — but ONLY if it's genuinely our data dir
+    // (contains claude-mem-lite.db), so a mistyped CLAUDE_MEM_DIR is never rm'd.
+    if (MEM_DATA_DIR !== homeDir) {
+      if (existsSync(join(MEM_DATA_DIR, 'claude-mem-lite.db'))) {
+        rmSync(MEM_DATA_DIR, { recursive: true, force: true });
+        ok(`Relocated data purged (${MEM_DATA_DIR})`);
+      } else if (existsSync(MEM_DATA_DIR)) {
+        warn(`CLAUDE_MEM_DIR (${MEM_DATA_DIR}) has no claude-mem-lite.db — left untouched. Remove manually if intended.`);
+      }
+    }
   } else {
-    log('Data preserved in ~/.claude-mem-lite/ (use --purge to remove)');
+    log('Data preserved (use --purge to remove)');
   }
 
   console.log('\n  Done!\n');
@@ -1383,7 +1406,7 @@ async function doctor() {
 
   // Update state
   try {
-    const stateFile = join(INSTALL_DIR, 'runtime', 'update-state.json');
+    const stateFile = join(MEM_DATA_DIR, 'runtime', 'update-state.json');
     if (existsSync(stateFile)) {
       const state = JSON.parse(readFileSync(stateFile, 'utf8'));
       const parts = [];
@@ -1439,11 +1462,14 @@ async function doctor() {
 
   // Stale temp files
   try {
-    const runtimeDir = join(INSTALL_DIR, 'runtime');
+    // hook-update + the episode workers write runtime/ + staging under DB_DIR
+    // (= MEM_DATA_DIR, env-aware), NOT the homedir code dir — scan there so doctor
+    // sees the real residue under relocation.
+    const runtimeDir = join(MEM_DATA_DIR, 'runtime');
     let staleCount = 0;
     const stalePatterns = ['.update-staging-', '.update-backup-'];
-    if (existsSync(INSTALL_DIR)) {
-      for (const f of readdirSync(INSTALL_DIR)) {
+    if (existsSync(MEM_DATA_DIR)) {
+      for (const f of readdirSync(MEM_DATA_DIR)) {
         if (stalePatterns.some(p => f.startsWith(p))) staleCount++;
       }
     }
@@ -1712,10 +1738,11 @@ function cleanup() {
   console.log(`\nclaude-mem-lite cleanup${dryRun ? ' (--dry-run)' : ''}\n`);
   let removed = 0;
 
-  // Clean .update-staging-* / .update-backup-* in INSTALL_DIR
+  // Clean .update-staging-* / .update-backup-* — hook-update writes these under
+  // DB_DIR (= MEM_DATA_DIR, env-aware), so scan the data dir, not the homedir code dir.
   const stalePatterns = ['.update-staging-', '.update-backup-'];
-  if (existsSync(INSTALL_DIR)) {
-    for (const f of readdirSync(INSTALL_DIR)) {
+  if (existsSync(MEM_DATA_DIR)) {
+    for (const f of readdirSync(MEM_DATA_DIR)) {
       if (stalePatterns.some(p => f.startsWith(p))) {
         if (dryRun) {
           ok(`Would remove: ${f}`);
@@ -1723,7 +1750,7 @@ function cleanup() {
           continue;
         }
         try {
-          rmSync(join(INSTALL_DIR, f), { recursive: true, force: true });
+          rmSync(join(MEM_DATA_DIR, f), { recursive: true, force: true });
           ok(`Removed: ${f}`);
           removed++;
         } catch (e) {
@@ -1733,8 +1760,8 @@ function cleanup() {
     }
   }
 
-  // Clean pending-* / ep-flush-* in runtime/
-  const runtimeDir = join(INSTALL_DIR, 'runtime');
+  // Clean pending-* / ep-flush-* in runtime/ (under the env-aware data dir)
+  const runtimeDir = join(MEM_DATA_DIR, 'runtime');
   if (existsSync(runtimeDir)) {
     for (const f of readdirSync(runtimeDir)) {
       if (f.startsWith('pending-') || f.startsWith('ep-flush-')) {

package/lib/citation-tracker.mjs

@@ -387,6 +387,42 @@ const IMPORTANCE_CAP = 3;
 const IMPORTANCE_FLOOR = 0;
 const UNCITED_STREAK_THRESHOLD = 3;
 
+// Adoption-rate gate (P5 ②). A project's cite-rate is SUM(cited_count) /
+// SUM(decay_seen_count) over its non-superseded observations: of every decay
+// resolution this project has ever produced, what fraction were citations.
+// Below ADOPTION_THRESHOLD with at least ADOPTION_MIN_SEEN resolutions on record,
+// the project has demonstrably not adopted the #NN convention, so we suppress
+// DEMOTION (never promotion) — see the construct-validity note on
+// applyCitationDecay. MIN_SEEN keeps the gate dormant for low-data projects so
+// the established behavior is preserved until there's enough signal to judge.
+const ADOPTION_THRESHOLD = 0.02;
+const ADOPTION_MIN_SEEN = 8;
+
+/**
+ * Compute a project's citation-adoption snapshot: total citations vs total decay
+ * resolutions on record, and their ratio. Read-only; safe to call before the
+ * decay transaction (the gate decision is made on the pre-mutation snapshot).
+ *
+ * @param {import('better-sqlite3').Database} db
+ * @param {string} project
+ * @returns {{cited: number, seen: number, rate: number}}
+ */
+export function computeCitationAdoption(db, project) {
+  const empty = { cited: 0, seen: 0, rate: 0 };
+  if (!db || !project) return empty;
+  try {
+    const row = db.prepare(`
+      SELECT COALESCE(SUM(cited_count), 0)       AS cited,
+             COALESCE(SUM(decay_seen_count), 0)  AS seen
+        FROM observations
+       WHERE project = ? AND superseded_at IS NULL
+    `).get(project);
+    const cited = row?.cited || 0;
+    const seen = row?.seen || 0;
+    return { cited, seen, rate: seen > 0 ? cited / seen : 0 };
+  } catch (e) { debugCatch(e, 'computeCitationAdoption'); return empty; }
+}
+
 /**
  * Apply the citation-feedback loop for one session: for each injected obs id,
  * decide cited vs uncited and mutate importance/streak/cited_count per spec.
@@ -398,6 +434,20 @@ const UNCITED_STREAK_THRESHOLD = 3;
  * - cross-project IDs are silently ignored by the WHERE clause.
  * - MEM_DISABLE_CITATION_DECAY=1 disables all writes; returns zeros.
  *
+ * CONSTRUCT-VALIDITY ASSUMPTION (P5): a "citation" is operationally two signals,
+ * neither of which is ground-truth behavioral impact:
+ *   1. the literal `#NN` token appears in main-thread assistant text (citedIds), and
+ *   2. (cite-back) the agent edited a file a prior lesson #NN had warned about —
+ *      unioned into citedIds by the Stop handler before this call.
+ * Signal 2 was added because signal 1 alone penalizes projects that act on a
+ * lesson without typing its id. Even so, both are proxies. For a project that has
+ * never cited anything (cite-rate below ADOPTION_THRESHOLD over ≥ADOPTION_MIN_SEEN
+ * resolutions), demotion is suppressed: absent any positive signal we cannot
+ * distinguish "useless lesson" from "useful lesson in a project that doesn't use
+ * the #NN convention," and a false demotion is the costlier error. The gate trades
+ * missed demotions (stale lessons linger) for avoided false demotions. Promotion
+ * is never gated — a single citation lifts the project's rate and re-enables decay.
+ *
  * @param {import('better-sqlite3').Database} db
  * @param {string} project
  * @param {Set<number>|Iterable<number>} injectedIds
@@ -413,6 +463,13 @@ export function applyCitationDecay(db, project, injectedIds, citedIds, sessionId
   if (injected.size === 0) return empty;
   const cited = citedIds instanceof Set ? citedIds : new Set(citedIds || []);
 
+  // Adoption gate (snapshot taken before any mutation this run). Suppress only
+  // demotion; promotion always proceeds. Threshold overridable via env.
+  const adoption = computeCitationAdoption(db, project);
+  const envThreshold = Number.parseFloat(process.env.CLAUDE_MEM_CITATION_ADOPTION_THRESHOLD);
+  const adoptionThreshold = Number.isFinite(envThreshold) && envThreshold >= 0 ? envThreshold : ADOPTION_THRESHOLD;
+  const suppressDemotion = adoption.seen >= ADOPTION_MIN_SEEN && adoption.rate < adoptionThreshold;
+
   const selectStmt = db.prepare(
     'SELECT id, importance, uncited_streak, last_decided_session_id FROM observations WHERE id = ? AND project = ?'
   );
@@ -457,7 +514,10 @@ export function applyCitationDecay(db, project, injectedIds, citedIds, sessionId
         promoted++;
       } else {
         const nextStreak = (row.uncited_streak || 0) + 1;
-        if (nextStreak >= UNCITED_STREAK_THRESHOLD) {
+        // Demote only when the streak is up AND the project has demonstrably
+        // adopted citations. A non-adopting project advances the streak (idempotent
+        // bookkeeping) but never loses importance — see construct-validity note.
+        if (nextStreak >= UNCITED_STREAK_THRESHOLD && !suppressDemotion) {
           updateDemote.run(IMPORTANCE_FLOOR, sessionId, Date.now(), id);
           demoted++;
         } else {

package/lib/cite-back-hint.mjs

@@ -17,6 +17,11 @@ import { EDIT_TOOLS } from '../utils.mjs';
 
 const MAX_FILES = 2;
 
+// Leader literal for the cite-back hint. Shared by the builder (below) and the
+// Stop-time signal extractor (extractCiteBackSignals) so the two can never drift
+// — the extractor finds hint emissions by this exact prefix.
+const CITE_BACK_HINT_LEADER = '[mem] ⚠ Cite-back:';
+
 export function buildCiteBackHint(episode, cooldown) {
   if (!episode || !cooldown) return null;
   const entries = episode.entries;
@@ -48,7 +53,7 @@ export function buildCiteBackHint(episode, cooldown) {
   // numeric framing is measurably harder to dismiss than a hedged hint.
   const totalLessons = matches.reduce((sum, m) => sum + m.ids.length, 0);
   const lines = [
-    `[mem] ⚠ Cite-back: edited ${matches.length} file(s) with ${totalLessons} prior lesson(s) this session. Save now if any was the root cause:`,
+    `${CITE_BACK_HINT_LEADER} edited ${matches.length} file(s) with ${totalLessons} prior lesson(s) this session. Save now if any was the root cause:`,
   ];
   for (const m of matches) {
     const fname = basename(m.file);
@@ -242,3 +247,36 @@ export function loadCiteBackForEpisode(episode, runtimeDir) {
   }
   return buildCiteBackHint(episode, cooldown);
 }
+
+// ─── extractCiteBackSignals (P5 ①) ──────────────────────────────────────────
+// Stop-time positive-citation signal. Scans the transcript for cite-back hint
+// emissions (PostToolUse attachment.stdout carrying CITE_BACK_HINT_LEADER — the
+// same source countUnsavedBugfixShape reads) and collects the `#NN` lesson ids
+// they name. Each id is an observation whose warned file the agent actually
+// EDITED this session — a behavioral citation even when the agent never typed
+// #NN. The Stop handler unions these into the cited set passed to
+// applyCitationDecay (lib/citation-tracker.mjs), so acting on a lesson promotes
+// it and lifts the project's adoption rate. Returns an empty set on missing path.
+const CITE_BACK_ID_RE = /#(\d{1,7})\b/g;
+
+export function extractCiteBackSignals(transcriptPath) {
+  const ids = new Set();
+  if (!transcriptPath || !existsSync(transcriptPath)) return ids;
+  let raw;
+  try { raw = readFileSync(transcriptPath, 'utf8'); } catch { return ids; }
+  for (const line of raw.split('\n')) {
+    if (!line.trim()) continue;
+    let entry;
+    try { entry = JSON.parse(line); } catch { continue; }
+    if (entry.type !== 'attachment') continue;
+    const stdout = entry.attachment?.stdout || '';
+    if (!stdout.includes(CITE_BACK_HINT_LEADER)) continue;
+    CITE_BACK_ID_RE.lastIndex = 0;
+    let m;
+    while ((m = CITE_BACK_ID_RE.exec(stdout))) {
+      const id = Number(m[1]);
+      if (Number.isInteger(id) && id > 0 && id < 1e7) ids.add(id);
+    }
+  }
+  return ids;
+}

package/lib/cli-flags.mjs

@@ -19,6 +19,21 @@
 
 const DEFAULT_STDERR_WRITE = msg => process.stderr.write(msg);
 
+/**
+ * True if `raw` is a clean integer or float-literal token — no trailing garbage,
+ * hex, or scientific notation. Float literals ARE accepted (callers truncate via
+ * parseInt, the deliberate #8277 decision); this only rejects shapes bare parseInt
+ * would silently coerce ("2abc"→2, "0x10"→0, "1e2"→1). Single source of the
+ * strict-shape rule shared by parseIntFlag and the reject-style numeric flags
+ * (save/update --importance, defer --priority).
+ *
+ * @param {string|number} raw Flag value as captured by parseArgs.
+ * @returns {boolean}
+ */
+export function isNumericToken(raw) {
+  return /^-?\d+(\.\d+)?$/.test(String(raw).trim());
+}
+
 /**
  * Validate and parse a CLI numeric flag with optional bounds.
  *
@@ -38,8 +53,15 @@ export function parseIntFlag(rawValue, opts) {
     return defaultValue;
   }
 
-  const parsed = parseInt(rawValue, 10);
-  if (!Number.isInteger(parsed) || parsed < min || parsed > max) {
+  // Reject trailing-garbage / hex / scientific tokens that bare parseInt would
+  // silently coerce by stopping at the first non-digit ("2abc"→2, "0x10"→0,
+  // "1e2"→1) — those slip past the Number.isInteger gate and violate the
+  // warn+default contract above. Float literals ("3.7"→3) stay ACCEPTED via
+  // parseInt truncation: that's the deliberate #8277 decision pinned by the
+  // 'rejects floats' case in cli-flags.test.mjs, so the shape check admits them.
+  const str = String(rawValue).trim();
+  const parsed = parseInt(str, 10);
+  if (!isNumericToken(str) || !Number.isInteger(parsed) || parsed < min || parsed > max) {
     const range = max === Number.MAX_SAFE_INTEGER ? `≥ ${min}` : `between ${min} and ${max}`;
     warn(`[mem] Invalid ${name} "${rawValue}" (must be an integer ${range}); using default ${defaultValue}\n`);
     return defaultValue;

package/lib/compress-core.mjs

@@ -10,11 +10,15 @@
 // granularity (CLI/MCP wrap all groups in one transaction; the hook transacts
 // each group). They no longer re-implement the mutation.
 //
-// NOTE: the summary INSERT still omits the observation_vectors write, matching
-// pre-extraction behavior. Fixing that (audit P5) is now a single change here
-// instead of three — but it is a behavior change, intentionally NOT bundled.
+// The summary INSERT also writes its TF-IDF observation_vectors row in the same
+// (caller-owned) transaction — fixed once here rather than in all three call
+// sites. Without it, FTS-miss queries that fall back to vector recall (CJK /
+// concept / paraphrase) could never reach compressed summaries; the LLM
+// smart-compress path already wrote vectors, so the deterministic path was the
+// sole gap (audit P6).
 
-import { isoWeekKey, COMPRESSED_AUTO } from '../utils.mjs';
+import { isoWeekKey, COMPRESSED_AUTO, debugCatch } from '../utils.mjs';
+import { getVocabulary, computeVector } from '../tfidf.mjs';
 import { scrubRecord } from './scrub-record.mjs';
 
 /**
@@ -90,6 +94,22 @@ export function compressGroup(db, proj, obs) {
   `).run(sessionId, proj, safe.text, dominantType, safe.title, safe.narrative, medianDate.toISOString(), medianEpoch);
   const summaryId = Number(summaryResult.lastInsertRowid);
 
+  // TF-IDF vector for the summary so it is reachable by vector recall (parity
+  // with save-observation.mjs and the LLM smart-compress path). Best-effort:
+  // vocab may be uninitialized on a fresh DB — a failure here must not abort the
+  // compression the caller is transacting.
+  try {
+    const vocab = getVocabulary(db);
+    if (vocab) {
+      const vec = computeVector(`${safe.title} ${safe.narrative}`, vocab);
+      if (vec) {
+        db.prepare(
+          'INSERT OR REPLACE INTO observation_vectors (observation_id, vector, vocab_version, created_at_epoch) VALUES (?, ?, ?, ?)'
+        ).run(summaryId, Buffer.from(vec.buffer), vocab.version, medianEpoch);
+      }
+    }
+  } catch (e) { debugCatch(e, 'compress-vector'); }
+
   const obsIds = obs.map((o) => o.id);
   const obsPh = obsIds.map(() => '?').join(',');
   db.prepare(`UPDATE observations SET compressed_into = ? WHERE id IN (${obsPh})`).run(summaryId, ...obsIds);

package/lib/dedup-constants.mjs

@@ -0,0 +1,35 @@
+// Dedup / merge similarity thresholds — single source of truth (P10).
+//
+// All values are Jaccard-space (word-set overlap, 0..1) unless noted. They were
+// scattered as bare literals and duplicate local consts across save-observation,
+// maintain-core, hook-llm, hook-optimize, mem-cli, server, and hook; converging
+// them here removes the drift risk and gives the P7 benchmark named knobs.
+// Vector-side constants (VOCAB_DIM / MIN_COSINE_SIMILARITY / RRF_K) deliberately
+// stay in tfidf.mjs next to the search engine that consumes them.
+//
+// Pure constants only — no imports, so nothing can import-cycle through this.
+
+// 0.7: near-duplicate cutoff for save-time dedup (5-min window, lib/save-observation)
+// and the hook-llm tier-1 title dedup. Catches "Modified X" / "Fixed X" restatements
+// (~70% word overlap) without collapsing distinct-but-related observations.
+export const DEDUP_JACCARD_THRESHOLD = 0.7;
+
+// 0.85: high-confidence auto-merge cutoff (maintain + optimize cluster-merge, CLI/MCP
+// dedup preview). Pairs at or above this merge without an LLM merge-decision call.
+export const AUTO_MERGE_THRESHOLD = 0.85;
+
+// 0.4: low bound of the LLM-review merge band [0.4, 0.85) in hook-optimize. Below it,
+// a pair is too dissimilar to be worth a merge-decision call.
+export const MERGE_JACCARD_LOW = 0.4;
+
+// 0.5: MinHash estimated-Jaccard pre-filter for the maintain O(n²) scan — skip the
+// exact-Jaccard compare when the cheap signature estimate is already below this.
+export const MINHASH_PRE_THRESHOLD = 0.5;
+
+// 0.7: MinHash pre-filter for the hook post-inject fuzzy-dedup pass. Stricter than
+// maintain's 0.5 to keep the inline inject path cheap (it runs in the hot Stop path).
+export const MINHASH_PREFILTER = 0.7;
+
+// 0.95: strict title-Jaccard cutoff for the hook post-inject fuzzy-dedup pass — only
+// collapse near-identical titles inline; anything softer waits for the maintain sweep.
+export const FUZZY_DEDUP_THRESHOLD = 0.95;

package/lib/maintain-core.mjs

@@ -14,13 +14,16 @@
 
 import { COMPRESSED_PENDING_PURGE, computeMinHash, estimateJaccardFromMinHash, jaccardSimilarity } from '../utils.mjs';
 import { rebuildVocabulary, computeVector, _resetVocabCache } from '../tfidf.mjs';
+import { DEDUP_JACCARD_THRESHOLD, MINHASH_PRE_THRESHOLD as MINHASH_PRE_THRESHOLD_SRC } from './dedup-constants.mjs';
 
 export const STALE_AGE_MS = 30 * 86400000;
 export const OP_CAP = 1000;
 export const SCAN_LIMIT = 500;
 export const DUPLICATE_LIMIT = 50;
-export const SIMILARITY_THRESHOLD = 0.7;
-export const MINHASH_PRE_THRESHOLD = 0.5;
+// Back-compat: maintain-core historically exported these names; both now source
+// their value from the single canonical lib/dedup-constants.mjs.
+export const SIMILARITY_THRESHOLD = DEDUP_JACCARD_THRESHOLD;
+export const MINHASH_PRE_THRESHOLD = MINHASH_PRE_THRESHOLD_SRC;
 // A memory injected this many times with zero citations is "pinned noise" that
 // the regular decay op can't touch (decay protects injection_count>0).
 export const PINNED_INJ_THRESHOLD = 8;

package/lib/save-observation.mjs

@@ -13,10 +13,10 @@
 
 import { jaccardSimilarity, scrubSecrets, computeMinHash, cjkBigrams, getCurrentBranch, debugCatch } from '../utils.mjs';
 import { getVocabulary, computeVector } from '../tfidf.mjs';
+import { DEDUP_JACCARD_THRESHOLD } from './dedup-constants.mjs';
 
 const DEDUP_WINDOW_MS = 5 * 60 * 1000;
 const DEDUP_RECENT_LIMIT = 50;
-const DEDUP_JACCARD_THRESHOLD = 0.7;
 
 /**
  * Save a new observation if it isn't a near-duplicate of one saved within the