claude-mem-lite 2.88.0 → 2.90.0

package/mem-cli.mjs

@@ -23,7 +23,7 @@ import {
 import { optimizePreview, optimizeRun } from './hook-optimize.mjs';
 import { buildSessionContextLines } from './hook-context.mjs';
 import { cmdAdopt, cmdUnadopt } from './adopt-cli.mjs';
-import { parseIntFlag } from './lib/cli-flags.mjs';
+import { parseIntFlag, isNumericToken } from './lib/cli-flags.mjs';
 import { auditMemdir, memdirPath } from './memdir.mjs';
 import { probeOtherSources as probeIdSources, bucketIdTokens } from './lib/id-routing.mjs';
 import { basename, join } from 'path';
@@ -34,6 +34,7 @@ import { readFileSync, existsSync, readdirSync } from 'fs';
 // move each cmdXxx into its own cli/<cmd>.mjs; mem-cli.mjs becomes pure dispatch.
 import { parseArgs, out, fail, relativeTime, fmtDateShort, parseIdToken, formatProbeHints } from './cli/common.mjs';
 import { saveObservation } from './lib/save-observation.mjs';
+import { AUTO_MERGE_THRESHOLD } from './lib/dedup-constants.mjs';
 import { countRecentHookErrors } from './lib/hook-telemetry.mjs';
 import {
   insertDeferred, listOpenWithOrdinal, dropDeferred,
@@ -70,16 +71,16 @@ function cmdSearch(db, args) {
     process.stderr.write(`[mem] Note: --from "${flags.from}" is after --to "${flags.to}"; this range is empty\n`);
   }
   const minImportance = flags.importance !== undefined ? parseInt(flags.importance, 10) : null;
-  if (minImportance !== null && (isNaN(minImportance) || minImportance < 1 || minImportance > 3)) {
+  // isNumericToken first: "2abc"→2 / "1e2"→1 would pass the range check and silently
+  // filter at a value the user never typed. Reject garbage like out-of-range does.
+  if (minImportance !== null && (!isNumericToken(flags.importance) || isNaN(minImportance) || minImportance < 1 || minImportance > 3)) {
     fail(`[mem] Invalid --importance "${flags.importance}". Must be 1, 2, or 3.`);
     return;
   }
   const branch = flags.branch || null;
-  const rawOffset = flags.offset !== undefined ? parseInt(flags.offset, 10) : NaN;
-  if (flags.offset !== undefined && (!Number.isInteger(rawOffset) || rawOffset < 0)) {
-    process.stderr.write(`[mem] Invalid --offset "${flags.offset}" (must be a non-negative integer); using 0\n`);
-  }
-  const offset = Number.isInteger(rawOffset) && rawOffset >= 0 ? rawOffset : 0;
+  // parseIntFlag (min=0) rejects garbage ("2abc"→2, "1e2"→1) the old isInteger check let
+  // through, warns once, and falls back to 0 — same WARN-style contract, now garbage-proof.
+  const offset = parseIntFlag(flags.offset, { name: '--offset', defaultValue: 0, min: 0 });
   const tier = flags.tier || null;
   if (tier && !['working', 'active', 'archive'].includes(tier)) {
     fail(`[mem] Invalid --tier "${tier}". Use: working, active, archive`);
@@ -125,8 +126,14 @@ function cmdSearch(db, args) {
   // so the post-merge sort has room to pick the best from each (paired-path with
   // server.mjs:377 — without this, obs gets systematically squeezed out by sessions).
   const isCrossSourceMode = !effectiveSource;
-  const perSourceLimit = isCrossSourceMode ? Math.max(limit * 3, offset + limit + 10) : limit;
-  const perSourceOffset = isCrossSourceMode ? 0 : offset;
+  // Over-fetch from offset 0 and apply --offset ONCE at the final slice (below) in
+  // ALL modes — mirrors server.mjs. Pushing OFFSET into the obs hybrid path was
+  // unreliable: its AND→OR fallback / vector / concept-cooccurrence stages re-add
+  // rows the SQL OFFSET already skipped, so engine-side paging dropped (or
+  // duplicated) rows on the --type/--tier/--importance/--branch path (a page that
+  // MCP returned came back empty).
+  const perSourceLimit = Math.max(limit * 3, offset + limit + 10);
+  const perSourceOffset = 0;
 
   const results = [];
   // Tracks whether AND returned 0 and OR recovered non-empty. Mirrors server.mjs
@@ -304,7 +311,10 @@ function cmdSearch(db, args) {
   }
   // else 'relevance' keeps BM25 score order (already sorted)
 
-  // Trim to limit with offset
+  // Trim to limit with offset. The engine always received perSourceOffset=0 and
+  // over-fetched (see above), so the merged+reranked `results` start at row 0 and
+  // the offset is applied exactly ONCE here — for every mode. `total` is the full
+  // match count (capped at perSourceLimit), enabling the "N of M" display.
   const total = results.length;
   const paged = results.slice(offset, offset + limit);
 
@@ -388,7 +398,9 @@ function cmdRecent(db, args) {
   const { positional, flags } = parseArgs(args);
   const rawArg = positional[0];
   const rawLimit = parseInt(rawArg, 10);
-  const isValid = Number.isInteger(rawLimit) && rawLimit > 0;
+  // isNumericToken first: "2abc"→2 / "1e2"→1 are positive integers that the bare check
+  // accepted silently; the positional path must reject garbage like the --limit flag does.
+  const isValid = rawArg !== undefined && isNumericToken(rawArg) && Number.isInteger(rawLimit) && rawLimit > 0;
   if (rawArg !== undefined && !isValid) {
     process.stderr.write(`[mem] Invalid count "${rawArg}" (must be a positive integer); using default 10\n`);
   }
@@ -691,7 +703,9 @@ function cmdTimeline(db, args) {
   const parseWindow = (label, raw) => {
     if (raw === undefined) return 5;
     const n = parseInt(raw, 10);
-    if (!Number.isInteger(n) || n < 0) {
+    // isNumericToken first: "2abc"→2 / "1e2"→1 are non-negative integers the bare check
+    // accepted silently; reject garbage tokens like the negative path already does.
+    if (!isNumericToken(raw) || !Number.isInteger(n) || n < 0) {
       process.stderr.write(`[mem] Invalid --${label} "${raw}" (must be a non-negative integer); using default 5\n`);
       return 5;
     }
@@ -924,7 +938,9 @@ function cmdSave(db, args) {
 
   // Explicit saves default to importance=2 (notable) — user chose to save
   const rawImp = flags.importance !== undefined ? parseInt(flags.importance, 10) : 2;
-  if (flags.importance !== undefined && (isNaN(rawImp) || rawImp < 1 || rawImp > 3)) {
+  // isNumericToken first: bare parseInt would coerce "2abc"→2 / "1e2"→1 and persist a
+  // wrong importance that silently skews ranking/decay. Float literals still truncate (#8277).
+  if (flags.importance !== undefined && (!isNumericToken(flags.importance) || isNaN(rawImp) || rawImp < 1 || rawImp > 3)) {
     fail(`[mem] Invalid importance "${flags.importance}". Must be 1, 2, or 3.`);
     return;
   }
@@ -1040,6 +1056,12 @@ function cmdDeferAdd(db, args) {
     return;
   }
   const priority = flags.priority !== undefined ? parseInt(flags.priority, 10) : 2;
+  // isNumericToken first: bare parseInt would coerce "3xyz"→3 and silently escalate a
+  // deferred item's urgency. Float literals still truncate (#8277).
+  if (flags.priority !== undefined && !isNumericToken(flags.priority)) {
+    fail(`[mem] Invalid --priority "${flags.priority}". Must be 1 (low), 2 (normal), or 3 (urgent).`);
+    return;
+  }
   if (![1, 2, 3].includes(priority)) {
     fail(`[mem] Invalid --priority "${flags.priority}". Must be 1 (low), 2 (normal), or 3 (urgent).`);
     return;
@@ -1254,6 +1276,7 @@ async function cmdStats(db, args) {
   const lowVal = db.prepare(`
     SELECT COUNT(*) as c FROM observations
     WHERE COALESCE(importance,1) = 1 AND COALESCE(access_count,0) = 0
+      AND COALESCE(compressed_into, 0) = 0
       AND created_at_epoch < ? ${projectFilter}
   `).get(thirtyDaysAgo, ...baseParams);
   const noiseRatio = obsTotal.c > 0 ? lowVal.c / obsTotal.c : 0;
@@ -1606,6 +1629,19 @@ function cmdUpdate(db, args) {
     return;
   }
 
+  // A value-less `--flag` (last arg, or immediately followed by another --flag)
+  // parses to boolean `true` (cli/common.mjs parseArgs). For string-valued fields
+  // that boolean would slip past the string-only empty guards below and reach the
+  // SQLite bind, surfacing a raw "TypeError: SQLite3 can only bind ..." stacktrace
+  // — the same accidental shell-strip class the empty-title guard (#8470) catches.
+  // Reject it cleanly for every string-valued update flag.
+  for (const key of ['title', 'narrative', 'lesson', 'lesson-learned', 'concepts']) {
+    if (flags[key] === true) {
+      fail(`[mem] --${key} requires a value (received a bare flag with no value).`);
+      return;
+    }
+  }
+
   const updates = [];
   const params = [];
   if (flags.title !== undefined) {
@@ -1628,7 +1664,9 @@ function cmdUpdate(db, args) {
   }
   if (flags.importance) {
     const imp = parseInt(flags.importance, 10);
-    if (isNaN(imp) || imp < 1 || imp > 3) {
+    // isNumericToken first: bare parseInt would coerce "2abc"→2 and UPDATE the row to a
+    // wrong importance. Float literals still truncate (#8277).
+    if (!isNumericToken(flags.importance) || isNaN(imp) || imp < 1 || imp > 3) {
       fail(`[mem] Invalid importance "${flags.importance}". Must be 1, 2, or 3.`);
       return;
     }
@@ -1730,8 +1768,16 @@ function cmdExport(db, args) {
     return;
   }
 
+  // Full round-trippable column set so `restore` rebuilds observations faithfully —
+  // content + value-signals (access/cited/uncited/injection/decay) + branch + timing.
+  // Additive vs the pre-v2.90 13-col shape; existing `export | jq '.[].title'` consumers
+  // are unaffected. id + memory_session_id are informational (restore remaps id and
+  // buckets under a restore session).
   const rows = db.prepare(`
-    SELECT id, project, type, title, subtitle, narrative, concepts, facts, lesson_learned, importance, files_modified, created_at, created_at_epoch
+    SELECT id, memory_session_id, project, type, title, subtitle, narrative, concepts, facts,
+           files_read, files_modified, lesson_learned, importance, branch,
+           access_count, cited_count, uncited_streak, injection_count, decay_seen_count,
+           last_accessed_at, created_at, created_at_epoch
     FROM observations WHERE ${wheres.join(' AND ')}
     ORDER BY created_at_epoch DESC LIMIT ?
   `).all(...params, limit);
@@ -1758,6 +1804,83 @@ function cmdExport(db, args) {
   }
 }
 
+// ─── Restore ───────────────────────────────────────────────────────────────
+// Inverse of `export` — the backup/restore half README:690 promises. Reuses
+// lib/save-observation.mjs so FK / FTS / TF-IDF vector / minhash / files-junction
+// stay consistent with cmdSave, then a targeted UPDATE re-applies the value-signals
+// (access/cited/uncited/injection/decay), branch, and concepts/facts/files_read that
+// saveObservation derives or zeros — so a restored backup keeps its citation-decay
+// history and original timing (created_at via the `now` param). Source ids are
+// discarded (local AUTOINCREMENT; export omits related_ids); session provenance
+// collapses to saveObservation's manual-<project> bucket (documented MVP tradeoff).
+function cmdRestore(db, argv) {
+  const { positional, flags } = parseArgs(argv);
+  const file = positional[0];
+  if (!file) { fail('[mem] Usage: claude-mem-lite restore <file> [--project P] [--dry-run]'); return; }
+  let raw;
+  try { raw = readFileSync(file, 'utf8'); }
+  catch (e) { fail(`[mem] Cannot read "${file}": ${e.message}`); return; }
+  const trimmed = raw.trim();
+  if (!trimmed) { out('[mem] Empty file — nothing to restore.'); return; }
+  let rows;
+  try {
+    rows = trimmed[0] === '['
+      ? JSON.parse(trimmed)
+      : trimmed.split('\n').filter(l => l.trim()).map(l => JSON.parse(l));
+  } catch (e) { fail(`[mem] "${file}" is not valid export JSON/JSONL: ${e.message}`); return; }
+  if (!Array.isArray(rows) || rows.length === 0) { out('[mem] No observations in file.'); return; }
+
+  const projOverride = flags.project ? resolveProject(db, flags.project) : null;
+  const dryRun = flags['dry-run'] === true || flags['dry-run'] === 'true';
+  const num = (v) => Number.isFinite(Number(v)) ? Math.trunc(Number(v)) : 0;
+
+  const dupCheck = db.prepare('SELECT id FROM observations WHERE project = ? AND title = ? AND created_at_epoch = ? LIMIT 1');
+  const signalUpdate = db.prepare(`UPDATE observations SET
+      subtitle = ?, concepts = ?, facts = ?, files_read = ?, branch = COALESCE(?, branch),
+      access_count = ?, cited_count = ?, uncited_streak = ?, injection_count = ?,
+      decay_seen_count = ?, last_accessed_at = ?
+    WHERE id = ?`);
+
+  let restored = 0, skipped = 0, malformed = 0;
+  for (const r of rows) {
+    if (!r || typeof r !== 'object' || !r.type || !r.title) { malformed++; continue; }
+    const project = projOverride || r.project || inferProject();
+    const createdEpoch = Number.isFinite(Number(r.created_at_epoch)) ? Number(r.created_at_epoch) : Date.now();
+    // Durable exact-dup guard — saveObservation's 5-min Jaccard window can't catch a
+    // re-restore of an old-timestamped backup, so gate on project+title+created_at.
+    if (dupCheck.get(project, r.title, createdEpoch)) { skipped++; continue; }
+    if (dryRun) { restored++; continue; }
+    try {
+      let files = [];
+      try { const fm = JSON.parse(r.files_modified || '[]'); if (Array.isArray(fm)) files = fm; } catch { /* leave [] */ }
+      const imp = num(r.importance);
+      const res = saveObservation(db, {
+        content: r.narrative || r.title,
+        title: r.title,
+        type: r.type,
+        importance: imp >= 1 && imp <= 3 ? imp : 1,
+        project,
+        files,
+        lesson_learned: r.lesson_learned || null,
+        now: new Date(createdEpoch),
+      });
+      if (res.kind !== 'saved') { skipped++; continue; } // saveObservation Jaccard dedup
+      // Re-apply the fields saveObservation zeros/derives so the backup is faithful.
+      signalUpdate.run(
+        r.subtitle || '', r.concepts || '', r.facts || '', r.files_read || '[]', r.branch ?? null,
+        num(r.access_count), num(r.cited_count), num(r.uncited_streak), num(r.injection_count),
+        num(r.decay_seen_count), r.last_accessed_at ?? null,
+        res.id,
+      );
+      restored++;
+    } catch (e) {
+      malformed++;
+      if (process.env.CLAUDE_MEM_DEBUG) process.stderr.write(`[mem] restore row failed: ${e.message}\n`);
+    }
+  }
+  out(`[mem] Restore${dryRun ? ' (dry-run)' : ''}: ${restored} restored, ${skipped} duplicate(s) skipped, ${malformed} malformed/failed from ${rows.length} row(s).`);
+}
+
 // ─── Compress ────────────────────────────────────────────────────────────────
 
 function cmdCompress(db, args) {
@@ -1845,7 +1968,6 @@ function cmdMaintain(db, args) {
     out(`  Pinned-but-uncited (inj>=${PINNED_INJ_THRESHOLD}, cited=0, imp>1): ${stats.pinned} — run: maintain execute --ops demote_pinned`);
     out(`  Pending purge: ${stats.pendingPurge} (compressed originals awaiting cleanup)`);
     if (duplicates.length > 0) {
-      const AUTO_MERGE_THRESHOLD = 0.85;
       const autoMergeable = duplicates.filter(d => parseFloat(d.similarity) >= AUTO_MERGE_THRESHOLD);
       const manualReview = duplicates.filter(d => parseFloat(d.similarity) < AUTO_MERGE_THRESHOLD);
 
@@ -1876,7 +1998,11 @@ function cmdMaintain(db, args) {
 
   // Execute
   const VALID_OPS = ['cleanup', 'decay', 'boost', 'demote_pinned', 'dedup', 'purge_stale', 'rebuild_vectors', 'vacuum'];
-  const opsStr = flags.ops || 'cleanup,decay,boost';
+  // Distinguish flag-absent (use default op set) from flag-present-but-empty
+  // (`--ops ""`, e.g. an unset shell var). The latter previously coerced via `||`
+  // to the destructive default cleanup,decay,boost and EXECUTED it; route it to the
+  // VALID_OPS check below instead so it's rejected like `--ops " "` / `--ops "decay,"`.
+  const opsStr = flags.ops === undefined ? 'cleanup,decay,boost' : String(flags.ops);
   const ops = opsStr.split(',').map(s => s.trim());
   const invalidOps = ops.filter(op => !VALID_OPS.includes(op));
   if (invalidOps.length > 0) {
@@ -2119,6 +2245,12 @@ function cmdRegistry(_memDb, args) {
     }
 
     if (action === 'import') {
+      // A bare value-less flag parses to boolean `true` (parseArgs); for these string
+      // fields that boolean reaches the SQLite bind in upsertResource and throws a raw
+      // TypeError — same class as the `update` guard above (#8470). Reject up front.
+      for (const key of ['name', 'resource-type', 'invocation-name', 'source', 'repo-url', 'local-path', 'intent-tags', 'domain-tags', 'trigger-patterns', 'capability-summary', 'keywords', 'tech-stack', 'use-cases']) {
+        if (flags[key] === true) { fail(`[mem] --${key} requires a value (received a bare flag with no value).`); return; }
+      }
       const name = flags.name;
       const resourceType = flags['resource-type'];
       if (!name || !resourceType) { fail('[mem] Usage: claude-mem-lite registry import --name N --resource-type skill|agent [--invocation-name I] [--capability-summary S]'); return; }
@@ -2140,6 +2272,11 @@ function cmdRegistry(_memDb, args) {
     }
 
     if (action === 'remove') {
+      // Bare value-less --name / --resource-type → boolean true → SQLite-bind crash
+      // on the DELETE below; reject like the import branch and the `update` guard.
+      for (const key of ['name', 'resource-type']) {
+        if (flags[key] === true) { fail(`[mem] --${key} requires a value (received a bare flag with no value).`); return; }
+      }
       const name = flags.name;
       const resourceType = flags['resource-type'];
       if (!name || !resourceType) { fail('[mem] Usage: claude-mem-lite registry remove --name N --resource-type skill|agent'); return; }
@@ -2414,6 +2551,7 @@ Commands:
     --concepts T        Space-separated concept tags
 
   export                Export observations as JSON/JSONL
+  restore <file>        Restore observations from an export file (JSON/JSONL); --dry-run to preview
     --project P         Filter by project
     --type T            Filter by type
     --format F          json (default) or jsonl
@@ -2641,6 +2779,13 @@ async function cmdImportJsonl(db, argv) {
   out(`[mem] Total: ${totalPrompts} prompts, ${totalObs} observations, ${totalOrphans} orphan tool_use, ${totalSkip} skipped from ${files.length} file(s)${errorTail}.`);
   if (totalPrompts > 0 || totalObs > 0) {
     out(`[mem] Try: claude-mem-lite recent 5 --project ${project}`);
+  } else if (totalSkip > 0 && errorCount === 0) {
+    // Nothing imported but every line was skipped — almost always the wrong file
+    // format (import-jsonl ingests Claude Code transcript JSONL, not `export` output,
+    // which is observation-shaped). Pre-fix this exited 0 with no signal, so pointing
+    // it at the wrong file looked like success. Make the no-op explicit (stdout, like
+    // the summary lines above).
+    out(`[mem] Warning: 0 imported, ${totalSkip} line(s) skipped — none matched the expected Claude Code transcript JSONL shape (user/assistant/tool_result). 'export' output is NOT re-importable via import-jsonl.`);
   }
 }
 
@@ -2865,6 +3010,7 @@ export async function run(argv) {
       case 'delete':    cmdDelete(db, cmdArgs); break;
       case 'update':    cmdUpdate(db, cmdArgs); break;
       case 'export':    cmdExport(db, cmdArgs); break;
+      case 'restore':   cmdRestore(db, cmdArgs); break;
       case 'compress':  cmdCompress(db, cmdArgs); break;
       case 'maintain':  cmdMaintain(db, cmdArgs); break;
       case 'optimize':  await cmdOptimize(db, cmdArgs); break;

package/nlp.mjs

@@ -218,6 +218,12 @@ export const FTS_STOP_WORDS = new Set([...BASE_STOP_WORDS]);
 export function sanitizeFtsQuery(query) {
   if (!query) return null;
   const cleaned = query
+    // Strip ASCII control chars / NUL FIRST. A NUL survives tokenization (it's not
+    // \s), gets phrase-quoted by expandToken, and then terminates SQLite's C string
+    // mid-phrase → FTS5 "unterminated string" throw, breaking the documented
+    // "never throws on MATCH" invariant. The metachar class below doesn't cover them.
+    // eslint-disable-next-line no-control-regex -- intentional: stripping control chars IS the fix
+    .replace(/[\x00-\x1f\x7f]/g, ' ')
     .replace(/[{}()[\]^~*:"\\]/g, ' ')
     .replace(/(^|\s)-/g, '$1')
     .trim();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "claude-mem-lite",
-  "version": "2.88.0",
-  "description": "Persistent long-term memory for Claude Code via MCP — captures coding decisions, bugfixes, and context across sessions. Hybrid FTS5 + TF-IDF search with episode batching. Single SQLite DB, no external services. Alternative to claude-mem with 600x lower cost.",
+  "version": "2.90.0",
+  "description": "Persistent long-term memory for Claude Code via MCP — captures coding decisions, bugfixes, and context across sessions. Hybrid FTS5 + TF-IDF search with episode batching. Single SQLite DB, no external services. A lighter, lower-cost alternative to claude-mem (episode batching + a smaller model; cost savings are an internal estimate, not a measured benchmark).",
   "type": "module",
   "packageManager": "npm@10.9.2",
   "engines": {
@@ -69,6 +69,7 @@
     "lib/save-observation.mjs",
     "lib/compress-core.mjs",
     "lib/maintain-core.mjs",
+    "lib/dedup-constants.mjs",
     "lib/deferred-work.mjs",
     "lib/upgrade-banner.mjs",
     "lib/scrub-record.mjs",

package/schema.mjs

@@ -8,9 +8,17 @@ import { join } from 'path';
 import { existsSync, mkdirSync, readdirSync, renameSync, rmSync, chmodSync } from 'fs';
 import { OBS_FTS_COLUMNS } from './utils.mjs';
 
+// DATA location — DB, managed resources, registry DB, runtime/. Honors
+// CLAUDE_MEM_DIR so users can relocate state to a larger/faster volume.
 export const DB_DIR = process.env.CLAUDE_MEM_DIR || join(homedir(), '.claude-mem-lite');
 export const DB_PATH = join(DB_DIR, 'claude-mem-lite.db');
 export const REGISTRY_DB_PATH = join(DB_DIR, 'resource-registry.db');
+// CODE / install location — server.mjs, hook.mjs, cli.mjs, package.json live
+// here. ALWAYS homedir-rooted: Claude Code's settings.json + MCP registration
+// bake ABSOLUTE paths to server.mjs/hooks, so the code must NOT follow the
+// CLAUDE_MEM_DIR relocation env var (mirrors install.mjs INSTALL_DIR). Equals
+// DB_DIR when CLAUDE_MEM_DIR is unset — the common, non-relocated case.
+export const CODE_DIR = join(homedir(), '.claude-mem-lite');
 
 // Increment when schema changes (tables, columns, indexes, FTS, migrations)
 //
@@ -54,13 +62,22 @@ export const REGISTRY_DB_PATH = join(DB_DIR, 'resource-registry.db');
 // re-runs the v28 observation_vectors cleanup) to clear the backlog leaked while
 // the warm-start fast-path left foreign_keys OFF. LATEST_MIGRATION_COLUMN is
 // unchanged (no new column) — decay_seen_count still exists at v35.
-export const CURRENT_SCHEMA_VERSION = 35;
+// v36 (v2.89.0): no DDL — narrows events_fts_au to `AFTER UPDATE OF title, body`.
+// The events FTS triggers (v2.31) were hand-written inline and inherited the
+// pre-v27 broad `AFTER UPDATE ON events` form, so every importance / accessed_count
+// / citation-decay bump thrashed events_fts (delete+reinsert) and reintroduced the
+// SQLITE_CORRUPT_VTAB blast radius v27 fixed for the other FTS tables. Version
+// bumped to force one migration pass; the conditional drop below replaces the
+// legacy trigger on existing DBs. LATEST_MIGRATION_COLUMN unchanged (no new column).
+// v37 (D#26): adds user_prompts.cc_session_id (additive, nullable). LATEST_MIGRATION_COLUMN
+// MOVES to it so the half-migrated-DB self-heal fast-path covers the new column.
+export const CURRENT_SCHEMA_VERSION = 37;
 
 // Sentinel column for the LATEST migration set. The fast-path uses this to
 // self-heal half-migrated DBs — schema_version bumped but column ALTERs rolled
 // back (observed once in dev during v2.74.0). Update both the column AND
 // (if needed) the table when adding a new migration batch.
-const LATEST_MIGRATION_COLUMN = { table: 'observations', column: 'decay_seen_count' };
+const LATEST_MIGRATION_COLUMN = { table: 'user_prompts', column: 'cc_session_id' };
 
 function hasLatestMigrationColumn(db) {
   try {
@@ -198,6 +215,14 @@ const MIGRATIONS = [
   // share the unrelated injection_count column. Same-source numerator
   // (cited_count) + same-source denominator = meaningful ratio.
   'ALTER TABLE observations ADD COLUMN decay_seen_count INTEGER NOT NULL DEFAULT 0',
+  // v37 (D#26 — parallel-session handoff content scoping): the Claude-Code session
+  // UUID per user prompt. handleUserPrompt writes hookData.session_id here so
+  // buildAndSaveHandoff can scope working_on to ONE CC session — concurrent (and
+  // within-12h-TTL sequential) same-project sessions previously merged each other's
+  // prompts because getSessionId() is project-scoped (no CC-UUID component). Nullable:
+  // legacy rows + non-CC/no-stdin invocations read back NULL and the handoff falls
+  // back to its legacy unfiltered query.
+  'ALTER TABLE user_prompts ADD COLUMN cc_session_id TEXT DEFAULT NULL',
 ];
 
 /**
@@ -348,6 +373,7 @@ export function initSchema(db) {
   db.exec(`CREATE INDEX IF NOT EXISTS idx_sess_sum_epoch ON session_summaries(created_at_epoch DESC, project)`);
   db.exec(`CREATE INDEX IF NOT EXISTS idx_obs_project_epoch_minhash ON observations(project, created_at_epoch DESC) WHERE minhash_sig IS NOT NULL`);
   db.exec(`CREATE INDEX IF NOT EXISTS idx_user_prompts_session ON user_prompts(content_session_id)`);
+  db.exec(`CREATE INDEX IF NOT EXISTS idx_user_prompts_cc ON user_prompts(cc_session_id) WHERE cc_session_id IS NOT NULL`);
   db.exec(`CREATE INDEX IF NOT EXISTS idx_obs_superseded ON observations(superseded_at) WHERE superseded_at IS NOT NULL`);
   db.exec(`CREATE INDEX IF NOT EXISTS idx_obs_branch ON observations(branch) WHERE branch IS NOT NULL`);
   db.exec(`CREATE INDEX IF NOT EXISTS idx_sessions_project ON sdk_sessions(project)`);
@@ -399,6 +425,20 @@ export function initSchema(db) {
     }
   } catch { /* non-critical */ }
 
+  // v36 migration: narrow events_fts_au like the v27 fix above. The events FTS
+  // triggers were hand-written inline (below) rather than via ensureFTS, so
+  // events_fts_au inherited the broad `AFTER UPDATE ON events` form and fires on
+  // every non-indexed bump (importance / accessed_count / citation-decay). Drop
+  // the legacy trigger when its stored DDL lacks the scoped `UPDATE OF` clause so
+  // the CREATE TRIGGER IF NOT EXISTS below reinstates the scoped form (handles
+  // re-run + fresh-DB: undefined row on a fresh DB is a no-op).
+  try {
+    const row = db.prepare(`SELECT sql FROM sqlite_master WHERE type='trigger' AND name='events_fts_au'`).get();
+    if (row && row.sql && !/\bAFTER\s+UPDATE\s+OF\s+/i.test(row.sql)) {
+      db.exec(`DROP TRIGGER IF EXISTS events_fts_au`);
+    }
+  } catch { /* non-critical — recreated below */ }
+
   // ─── v2.31 T6: events table + FTS5 (activity namespace) ───────────────────
   // Independent namespace for bugfix/lesson/bug/discovery/refactor/feature/
   // observation/decision types. Isolated from observations to avoid polluting
@@ -443,7 +483,9 @@ export function initSchema(db) {
       VALUES ('delete', old.id, COALESCE(old.title,''), COALESCE(old.body,''), old.event_type, old.project);
     END;
 
-    CREATE TRIGGER IF NOT EXISTS events_fts_au AFTER UPDATE ON events BEGIN
+    -- v36: scoped to title, body (the FTS-indexed columns) so non-indexed bumps
+    -- (importance / accessed_count / citation-decay) no longer thrash events_fts.
+    CREATE TRIGGER IF NOT EXISTS events_fts_au AFTER UPDATE OF title, body ON events BEGIN
       INSERT INTO events_fts(events_fts, rowid, title, body, event_type, project)
       VALUES ('delete', old.id, COALESCE(old.title,''), COALESCE(old.body,''), old.event_type, old.project);
       INSERT INTO events_fts(rowid, title, body, event_type, project)

package/search-engine.mjs

@@ -257,11 +257,12 @@ export function searchObservationsHybrid(db, ctx) {
       project: args.project ?? null,
       type: args.obs_type ?? null,
       vocabVersion: vocab.version,
+      minCosine: ctx.minCosine,   // undefined → MIN_COSINE_SIMILARITY (benchmark sweep override)
     });
     if (vecResults.length === 0) return results;
 
     if (results.length > 0) {
-      const rrfRanking = rrfMerge(results, vecResults);
+      const rrfRanking = rrfMerge(results, vecResults, ctx.rrfK);  // undefined → RRF_K
       const resultMap = new Map(results.map(r => [r.id, r]));
       for (const vr of vecResults) {
         if (!resultMap.has(vr.id)) {

package/server.mjs

@@ -36,6 +36,7 @@ import { ensureRegistryDb, upsertResource } from './registry.mjs';
 import { searchResources } from './registry-retriever.mjs';
 import { probeOtherSources as probeIdSources, parseIdToken, bucketIdTokens } from './lib/id-routing.mjs';
 import { saveObservation } from './lib/save-observation.mjs';
+import { AUTO_MERGE_THRESHOLD } from './lib/dedup-constants.mjs';
 import {
   insertDeferred, listOpenWithOrdinal, dropDeferred,
   resolveDeferredIds, closeDeferredItems,
@@ -474,7 +475,12 @@ server.registerTool(
           `SELECT id, compressed_into, superseded_at, memory_session_id, project, importance, last_accessed_at, created_at_epoch, type FROM observations WHERE id IN (${placeholders})`
         ).all(...obsIds);
         const rowMap = new Map(fullRows.map(r => [r.id, r]));
-        const tierCtx = { now: Date.now(), currentProject: currentProject, currentSessionId: '' };
+        // Use the explicitly-requested project for tier classification, not the
+        // CWD-inferred one — else computeTier's "obs.project === currentProject"
+        // (working/active rules) fails for cross-project searches and the tier=
+        // filter silently drops valid rows. mem_stats/mem_browse already resolve
+        // args.project first; this restores parity.
+        const tierCtx = { now: Date.now(), currentProject: args.project || currentProject, currentSessionId: '' };
         const filtered = results.filter(r => {
           if (r.source !== 'obs') return true;
           const full = rowMap.get(r.id);
@@ -1107,6 +1113,7 @@ server.registerTool(
     const lowVal = db.prepare(`
       SELECT COUNT(*) as c FROM observations
       WHERE COALESCE(importance,1) = 1 AND COALESCE(access_count,0) = 0
+        AND COALESCE(compressed_into, 0) = 0
         AND created_at_epoch < ? ${projectFilter}
     `).get(thirtyDaysAgo, ...baseParams);
 
@@ -1250,7 +1257,6 @@ server.registerTool(
         `  Pending purge (idle-marked): ${stats.pendingPurge}`,
       ];
       if (duplicates.length > 0) {
-        const AUTO_MERGE_THRESHOLD = 0.85;
         const autoMergeable = duplicates.filter(d => parseFloat(d.similarity) >= AUTO_MERGE_THRESHOLD);
         const manualReview = duplicates.filter(d => parseFloat(d.similarity) < AUTO_MERGE_THRESHOLD);
 

package/source-files.mjs

@@ -86,6 +86,11 @@ export const SOURCE_FILES = [
   // Statically imported by mem-cli.mjs (cmdMaintain), server.mjs (mem_maintain),
   // and hook.mjs (handleAutoMaintain) — missing it would break maintain on auto-update.
   'lib/maintain-core.mjs',
+  // P10 dedup/merge threshold constants — single source of truth for the Jaccard
+  // dedup/merge cutoffs. Statically imported by hook.mjs, hook-llm.mjs,
+  // hook-optimize.mjs, mem-cli.mjs, server.mjs, and the save/maintain cores;
+  // missing it from the manifest would break those paths on auto-update.
+  'lib/dedup-constants.mjs',
   // v2.70 deferred-work: carry-forward TODO primitives. Statically imported by
   // server.mjs (mem_defer family) and mem-cli.mjs (defer subcommand).
   'lib/deferred-work.mjs',

package/tfidf.mjs

@@ -10,6 +10,10 @@ import { createHash } from 'crypto';
 export const VOCAB_DIM = 512;
 export const MIN_COSINE_SIMILARITY = 0.05;
 export const VECTOR_SCAN_LIMIT = 500;
+// Reciprocal Rank Fusion constant. Higher k flattens the rank-position weighting
+// (BM25 and vector lists contribute more equally); lower k lets the top few ranks
+// dominate. 60 is the de-facto RRF default and balances the two retrievers here.
+export const RRF_K = 60;
 
 const VOCAB_STOP_WORDS = new Set([
   ...BASE_STOP_WORDS,
@@ -192,7 +196,7 @@ export function _resetVocabCache() { _vocabCache = null; }
  * @param {object} db - better-sqlite3 database
  * @returns {{ terms: Map<string, {index: number, idf: number}>, version: string, dim: number } | null}
  */
-export function buildVocabulary(db) {
+export function buildVocabulary(db, { dim = VOCAB_DIM } = {}) {
   const rows = db.prepare(`
     SELECT title, narrative, concepts FROM observations
     WHERE COALESCE(compressed_into, 0) = 0 AND superseded_at IS NULL
@@ -217,7 +221,7 @@ export function buildVocabulary(db) {
     .filter(([term, freq]) => !isNoiseTerm(term) && freq >= 2)
     .map(([term, freq]) => ({ term, df: freq, idf: idf(freq), ig: freq * idf(freq) }))
     .sort((a, b) => b.ig - a.ig)
-    .slice(0, VOCAB_DIM);
+    .slice(0, dim);
 
   // Build terms map with index and IDF
   const terms = new Map();
@@ -229,7 +233,7 @@ export function buildVocabulary(db) {
   const termList = sortedTerms.map(e => e.term).join(',');
   const version = createHash('md5').update(termList).digest('hex').slice(0, 12);
 
-  const vocab = { terms, version, dim: VOCAB_DIM };
+  const vocab = { terms, version, dim };
   _vocabCache = vocab;
   return vocab;
 }
@@ -239,8 +243,8 @@ export function buildVocabulary(db) {
  * @param {object} db - better-sqlite3 database
  * @returns {object|null} The new vocabulary
  */
-export function rebuildVocabulary(db) {
-  const vocab = buildVocabulary(db);
+export function rebuildVocabulary(db, opts) {
+  const vocab = buildVocabulary(db, opts);
   if (!vocab) return null;
 
   const insertStmt = db.prepare(
@@ -358,7 +362,7 @@ export function cosineSimilarity(a, b) {
 const VECTOR_TIME_WINDOW_MS = 90 * 24 * 60 * 60 * 1000; // 90 days
 const VECTOR_MIN_RESULTS = 50; // fallback to full scan if time-window yields fewer
 
-export function vectorSearch(db, queryVec, { project, type, vocabVersion, limit = VECTOR_SCAN_LIMIT }) {
+export function vectorSearch(db, queryVec, { project, type, vocabVersion, limit = VECTOR_SCAN_LIMIT, minCosine = MIN_COSINE_SIMILARITY }) {
   if (!queryVec) return [];
 
   const now = Date.now();
@@ -403,7 +407,7 @@ export function vectorSearch(db, queryVec, { project, type, vocabVersion, limit
   for (const row of rows) {
     const vec = new Float32Array(row.vector.buffer.slice(row.vector.byteOffset, row.vector.byteOffset + row.vector.byteLength));
     const sim = cosineSimilarity(queryVec, vec);
-    if (sim > MIN_COSINE_SIMILARITY) results.push({ id: row.observation_id, similarity: sim });
+    if (sim > minCosine) results.push({ id: row.observation_id, similarity: sim });
   }
   results.sort((a, b) => b.similarity - a.similarity);
   return results.slice(0, 20);
@@ -418,7 +422,7 @@ export function vectorSearch(db, queryVec, { project, type, vocabVersion, limit
  * @param {number} k - RRF constant (default 60)
  * @returns {{ id: number, rrfScore: number }[]}
  */
-export function rrfMerge(bm25Results, vectorResults, k = 60) {
+export function rrfMerge(bm25Results, vectorResults, k = RRF_K) {
   const scores = new Map();
   bm25Results.forEach((r, i) => {
     scores.set(r.id, (scores.get(r.id) ?? 0) + 1 / (k + i + 1));