claude-mem-lite 3.42.0 → 3.44.0

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
   "plugins": [
     {
       "name": "claude-mem-lite",
-      "version": "3.42.0",
+      "version": "3.44.0",
       "source": "./",
       "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)."
     }

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "3.42.0",
+  "version": "3.44.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).",
   "author": {
     "name": "sdsrss"

package/hook-optimize.mjs

@@ -929,7 +929,23 @@ export async function optimizeRun(db, { tasks, maxItems = 15, force = false, ree
     try {
       switch (task) {
         case 're-enrich':
-          results.reenrich = await executeReenrich(db, budget.reenrich, { scope: reenrichScope, project });
+          if (reenrichScope === 'narrow') {
+            // P1-2: the default maintenance pass covers BOTH narrow (fill lesson/concepts on
+            // fully-degraded rows) AND aliases (backfill search_aliases on lesson-bearing
+            // manual saves that narrow+wide both skip — mem_save writes no aliases, so without
+            // this they stay paraphrase-unfindable). Split the budget so neither starves.
+            // An explicit --scope wide|aliases still runs exactly that one scope (below).
+            const aliasBudget = Math.max(1, Math.floor(budget.reenrich / 2));
+            const narrowRes = await executeReenrich(db, budget.reenrich - aliasBudget, { scope: 'narrow', project });
+            const aliasRes = await executeReenrich(db, aliasBudget, { scope: 'aliases', project });
+            results.reenrich = {
+              processed: (narrowRes.processed || 0) + (aliasRes.processed || 0),
+              skipped: (narrowRes.skipped || 0) + (aliasRes.skipped || 0),
+              byScope: { narrow: narrowRes, aliases: aliasRes },
+            };
+          } else {
+            results.reenrich = await executeReenrich(db, budget.reenrich, { scope: reenrichScope, project });
+          }
           break;
         case 'normalize':
           results.normalize = await executeNormalize(db, force, { project });

package/hook-update.mjs

@@ -3,7 +3,7 @@
 // Skips in dev mode (symlinked installs). Silent on network failure.
 
 import { execSync, execFileSync } from 'node:child_process';
-import { readFileSync, writeFileSync, copyFileSync, cpSync, readdirSync, existsSync, lstatSync, mkdirSync, rmSync, renameSync, chmodSync } from 'node:fs';
+import { readFileSync, writeFileSync, copyFileSync, cpSync, readdirSync, existsSync, lstatSync, mkdirSync, mkdtempSync, rmSync, renameSync, chmodSync } from 'node:fs';
 import { join, dirname, resolve } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { tmpdir, homedir } from 'node:os';
@@ -305,12 +305,22 @@ async function loadReleaseManifest(sourceDir) {
   }
 }
 
+// Create a private (0700), unpredictably-named staging dir under the system tmpdir.
+// mkdtempSync is atomic and owner-only, closing the predictable-name TOCTOU the old
+// `join(tmpdir(), \`...-${Date.now()}\`)` + mkdirSync(recursive) left open: in a
+// world-writable /tmp a local user could pre-create or symlink that guessable path before
+// we downloaded the tarball / ran validate→install into it. mkdirSync(recursive) succeeds
+// on an existing (attacker-owned) dir; mkdtempSync fails closed unless it creates a fresh
+// one. Mirrors the repair() path (install.mjs) which already uses mkdtempSync. (P3-4)
+export function createUpdateTmpDir() {
+  return mkdtempSync(join(tmpdir(), 'claude-mem-lite-update-'));
+}
+
 // ── Download & Install ─────────────────────────────────────
 // Direct file copy instead of running old install.mjs (avoids symlink overwrite in dev)
 async function downloadAndInstall(tarballUrl, expectedVersion, assets = []) {
-  const tmpDir = join(tmpdir(), `claude-mem-lite-update-${Date.now()}`);
+  const tmpDir = createUpdateTmpDir();
   try {
-    mkdirSync(tmpDir, { recursive: true });
 
     // Download tarball via curl (available on all supported platforms)
     // Validate URL to prevent command injection via crafted tarball URLs
@@ -389,6 +399,19 @@ export function validateExtractedTarball(sourceDir, expectedVersion, expectedNam
   return { ok: true };
 }
 
+// Pure downgrade-guard predicate (exported for unit testing). True when `relVersion` is
+// strictly OLDER than the installed `localVersion`. Under signing an attacker cannot forge a
+// release, but CAN replay an older validly-signed one (a since-patched version) by pinning the
+// GitHub "latest" API response — so repair(), which installs whatever fetchLatestRelease()
+// resolves, must refuse to move BACKWARD (parity with checkForUpdate, which only installs when
+// compareVersions(latest,current) > 0). A null/unknown local version (a broken install that
+// genuinely needs repair, or an unreadable package.json) is allowed through — fail toward
+// recoverability, since the signature check downstream still gates authenticity. (P3-3)
+export function isRepairDowngrade(relVersion, localVersion) {
+  if (!relVersion || !localVersion) return false;
+  return compareVersions(relVersion, localVersion) < 0;
+}
+
 // ── Release signature verification (P1 supply-chain hardening) ──────────────
 // Embedded Ed25519 PUBLIC key (SPKI PEM). ACTIVE since v3.20.0 — auto-update now
 // FAILS CLOSED: a release missing valid signature assets is refused (the matching

package/hook.mjs

@@ -47,7 +47,7 @@ import { handleLLMEpisode, handleLLMSummary, saveObservation, buildImmediateObse
 import { scrubRecord } from './lib/scrub-record.mjs';
 import { formatHookError } from './lib/native-binding-hint.mjs';
 import { selectCompressionCandidates, groupByProjectWeek, compressGroup } from './lib/compress-core.mjs';
-import { cleanupBroken, decayAndMarkIdle, boostAccessed, selectFuzzyDedupeIds, hardDeleteCandidateCount, purgeStale, recoverOrphanedChildren, recoverBuriedLessons } from './lib/maintain-core.mjs';
+import { cleanupBroken, decayAndMarkIdle, boostAccessed, selectFuzzyDedupeIds, hardDeleteCandidateCount, purgeStale, recoverOrphanedChildren, recoverBuriedLessons, sweepDeferredWorkOrphans } from './lib/maintain-core.mjs';
 import { snapshotDb } from './lib/db-backup.mjs';
 import {
   extractCitationsFromTranscript,
@@ -851,6 +851,11 @@ function runSessionStartAutoMaintain(db) {
       const lessonsHealed = recoverBuriedLessons(db, mctx);
       if (lessonsHealed > 0) debugLog('DEBUG', 'auto-maintain', `healed ${lessonsHealed} lesson rows buried at importance 0`);
 
+      // Heal deferred_work rows whose closing obs / source prompt was deleted while FK was OFF
+      // (dangling ref foreign_key_check flags). Applies the ON DELETE SET NULL the FK would.
+      const deferredHealed = sweepDeferredWorkOrphans(db, mctx);
+      if (deferredHealed > 0) debugLog('DEBUG', 'auto-maintain', `healed ${deferredHealed} deferred-work rows with dangling references`);
+
       const { decayed, idleMarked } = decayAndMarkIdle(db, mctx);
       if (decayed > 0) debugLog('DEBUG', 'auto-maintain', `decayed ${decayed} stale observations`);
       if (idleMarked > 0) debugLog('DEBUG', 'auto-maintain', `marked ${idleMarked} idle as pending-purge`);

package/install.mjs

@@ -1996,14 +1996,23 @@ async function repair() {
     // repo/TLS-MITM compromise achieved RCE, bypassing the Ed25519 signed-release control that
     // the manual `update` path enforces. Lazy import so a missing/broken hook-update dependency
     // degrades to the manual fallback (fail-closed) rather than to unverified auto-install.
-    let fetchLatestRelease, verifyReleaseAuthenticity;
+    let fetchLatestRelease, verifyReleaseAuthenticity, validateExtractedTarball, isRepairDowngrade, getCurrentVersion;
     try {
-      ({ fetchLatestRelease, verifyReleaseAuthenticity } = await import('./hook-update.mjs'));
+      ({ fetchLatestRelease, verifyReleaseAuthenticity, validateExtractedTarball, isRepairDowngrade, getCurrentVersion } = await import('./hook-update.mjs'));
     } catch (e) {
       throw new Error(`cannot load the verified-update path (${e.message}) — refusing to auto-install unverified code`, { cause: e });
     }
     const rel = await fetchLatestRelease();
     if (!rel || !rel.tarballUrl) throw new Error('could not resolve the latest release (network / rate-limit)');
+    // Rollback guard: refuse to repair BACKWARD onto an older validly-signed release replayed
+    // as "latest" (the only attack signing leaves open). Skipped when the local version is
+    // unreadable — a broken install still needs repair; the signature check below still gates
+    // authenticity either way.
+    let localVersion = null;
+    try { localVersion = getCurrentVersion(); } catch { /* broken install → allow repair */ }
+    if (isRepairDowngrade(rel.version, localVersion)) {
+      throw new Error(`refusing to repair BACKWARD: resolved release v${rel.version} is older than installed v${localVersion} (possible signed-release rollback)`);
+    }
     // URL allow-list mirrors hook-update.downloadAndInstall — only github.com tarball URLs.
     if (!/^https:\/\/(?:api\.)?github\.com\/[a-zA-Z0-9./_-]+$/.test(rel.tarballUrl)) {
       throw new Error(`refusing suspicious tarball URL: ${rel.tarballUrl}`);
@@ -2015,6 +2024,11 @@ async function repair() {
     log('Extracting...');
     execFileSync('tar', ['xzf', tarballPath, '-C', stagingDir, '--strip-components=1'],
       { timeout: 30000, stdio: ['ignore', 'pipe', 'inherit'] });
+    // Defense-in-depth on the extracted tarball (name + version === resolved tag + entry
+    // points) BEFORE the signature check — parity with hook-update.downloadAndInstall. Catches
+    // a wrong-version / truncated / squatter artifact whose package.json doesn't match the tag.
+    const tarballValid = validateExtractedTarball(stagingDir, rel.version);
+    if (!tarballValid.ok) throw new Error(`extracted tarball failed validation: ${tarballValid.reason}`);
     // Verify the Ed25519 signature BEFORE running the downloaded install.mjs. Fail-closed:
     // any tampering / missing-signature / fetch-failure aborts to the manual fallback.
     log('Verifying release signature...');

package/lib/export-columns.mjs

@@ -0,0 +1,26 @@
+// Single source of truth for the observation columns that `export` emits and `restore`
+// reads back. Both the CLI (`cmdExport` in mem-cli.mjs) and the MCP `mem_export` tool
+// (server.mjs) build their SELECT from this list so the two surfaces can never drift.
+//
+// v3.42 audit HIGH-2: the MCP export handler had its own narrower 16-column SELECT while
+// the CLI export carried 24 — missing exactly the columns cmdRestore reads back
+// (text / files_read / search_aliases / cited_count / uncited_streak / injection_count /
+// decay_seen_count / last_accessed_at). A backup taken via MCP export then restored via CLI
+// silently collapsed every empty-`narrative` row (import-jsonl / cold-start bodies live in
+// `text`) to its bare title — unrecoverable AND unsearchable. Sharing one list closes that
+// twin-drift class permanently.
+//
+// Full round-trippable set: content + value-signals (access/cited/uncited/injection/decay)
+// + branch + timing. `id` + `memory_session_id` are informational (restore remaps id and
+// buckets under a synthetic restore session). Session-idempotency keys (last_decided/
+// last_cited_session_id, demoted_at, optimized_at) are intentionally NOT exported — they are
+// meaningless after a row is re-bucketed under a restore session.
+export const EXPORT_COLUMNS = [
+  'id', 'memory_session_id', 'project', 'type', 'title', 'subtitle', 'narrative', 'text',
+  'concepts', 'facts', 'files_read', 'files_modified', 'lesson_learned', 'search_aliases',
+  'importance', 'branch', 'access_count', 'cited_count', 'uncited_streak', 'injection_count',
+  'decay_seen_count', 'last_accessed_at', 'created_at', 'created_at_epoch',
+];
+
+// The SELECT column fragment (comma-joined) — drop into `SELECT ${EXPORT_COLUMNS_SQL} FROM …`.
+export const EXPORT_COLUMNS_SQL = EXPORT_COLUMNS.join(', ');

package/lib/maintain-core.mjs

@@ -140,6 +140,30 @@ export function recoverBuriedLessons(db, { projectFilter = '', baseParams = [] }
   `).run(...baseParams).changes;
 }
 
+// Heal deferred_work rows whose closing observation / source prompt was hard-deleted while
+// foreign_keys was OFF. The warm-start fast-path deliberately runs with FK disabled (schema.mjs
+// early migrations require cascade off), so the column's `ON DELETE SET NULL` never fired and a
+// dangling closed_by_obs_id / source_prompt_id survives — exactly what `PRAGMA foreign_key_check`
+// flags. This applies the SET NULL the FK would have. Closure state lives in status/
+// closed_at_epoch, NOT the back-ref, so nulling the id does NOT reopen a done item — it only drops
+// a pointer to a row that no longer exists. NON-DESTRUCTIVE + idempotent (a no-op once no dangling
+// refs remain), so safe to run unconditionally alongside recoverOrphanedChildren. (P3-5)
+export function sweepDeferredWorkOrphans(db, { projectFilter = '', baseParams = [] } = {}) {
+  const obs = db.prepare(`
+    UPDATE deferred_work SET closed_by_obs_id = NULL
+    WHERE closed_by_obs_id IS NOT NULL
+      AND NOT EXISTS (SELECT 1 FROM observations o WHERE o.id = deferred_work.closed_by_obs_id)
+      ${projectFilter}
+  `).run(...baseParams).changes;
+  const prompt = db.prepare(`
+    UPDATE deferred_work SET source_prompt_id = NULL
+    WHERE source_prompt_id IS NOT NULL
+      AND NOT EXISTS (SELECT 1 FROM user_prompts p WHERE p.id = deferred_work.source_prompt_id)
+      ${projectFilter}
+  `).run(...baseParams).changes;
+  return obs + prompt;
+}
+
 export function cleanupBroken(db, { projectFilter, baseParams, opCap = OP_CAP }) {
   const doomed = db.prepare(`
     SELECT id FROM observations

package/lib/search-core.mjs

@@ -24,7 +24,7 @@
 // keys (date=created_at, text=prompt_text, session=content_session_id) so each
 // surface's renderer reads its own field names off a single row shape.
 
-import { sanitizeFtsQuery, relaxFtsQueryToOr, SESS_BM25, DEFAULT_DECAY_HALF_LIFE_MS } from '../utils.mjs';
+import { sanitizeFtsQuery, relaxFtsQueryToOr, SESS_BM25, EVT_BM25, DEFAULT_DECAY_HALF_LIFE_MS } from '../utils.mjs';
 import { cjkPrecisionOk, extractCjkLikePatterns } from '../nlp.mjs';
 import { computeTier } from '../tier.mjs';
 import { countSearchTotal, attachBodyTokens } from '../search-engine.mjs';
@@ -213,6 +213,35 @@ export function searchPromptsFts(db, { query, ftsQuery, project = null, epochFro
     .map((r) => ({ ...r, score: 0 }));
 }
 
+/**
+ * Event FTS search (events table via events_fts) with recency decay + same-project boost —
+ * the mirror of searchSessionsFts for the events source. Events are the CANONICAL store for
+ * event-typed memories (persistHaikuSummary upgrade-deletes the pre-saved observations row and
+ * inserts here), so without this leg the bugfix/feature/decision history is unreachable by
+ * mem_search. Excludes superseded events (superseded_at_epoch); events has no low-signal/noise
+ * column, so no noise gate (parity with searchEvents in lib/activity.mjs). Returns raw rows
+ * { id, event_type, title, body, project, importance, file_paths, created_at_epoch, score }.
+ */
+export function searchEventsFts(db, { ftsQuery, project = null, projectBoost = null, epochFrom = null, epochTo = null, perSourceLimit, perSourceOffset = 0 }) {
+  const wheres = ['events_fts MATCH ?', 'e.superseded_at_epoch IS NULL'];
+  const params = [Date.now(), projectBoost, projectBoost, ftsQuery];
+  if (project) { wheres.push('e.project = ?'); params.push(project); }
+  if (epochFrom !== null) { wheres.push('e.created_at_epoch >= ?'); params.push(epochFrom); }
+  if (epochTo !== null) { wheres.push('e.created_at_epoch <= ?'); params.push(epochTo); }
+  params.push(perSourceLimit, perSourceOffset);
+  return db.prepare(`
+    SELECT e.id, e.event_type, e.title, e.body, e.project, e.importance, e.file_paths, e.created_at_epoch,
+           ${EVT_BM25}
+             * (1.0 + EXP(-0.693 * MAX(0, ? - e.created_at_epoch) / ${DEFAULT_DECAY_HALF_LIFE_MS}.0))
+             * (CASE WHEN ? IS NOT NULL AND e.project = ? THEN 2.0 ELSE 1.0 END) as score
+    FROM events_fts
+    JOIN events e ON events_fts.rowid = e.id
+    WHERE ${wheres.join(' AND ')}
+    ORDER BY score
+    LIMIT ? OFFSET ?
+  `).all(...params);
+}
+
 /**
  * Normalize each source's BM25 scores to [-1, 0] before cross-source merge.
  * Prevents observations (BM25 can reach -40) from systematically outranking
@@ -221,7 +250,7 @@ export function searchPromptsFts(db, { query, ftsQuery, project = null, epochFro
  * -1.0. Mutates `results` in place; callers re-sort afterwards.
  */
 export function normalizeCrossSourceScores(results, sourceKey) {
-  for (const src of ['obs', 'session', 'prompt']) {
+  for (const src of ['obs', 'session', 'prompt', 'event']) {
     const srcResults = results.filter((r) => r[sourceKey] === src && r.score !== null && r.score !== undefined);
     if (srcResults.length < 2) continue;
     const maxAbs = Math.max(...srcResults.map((r) => Math.abs(r.score)));
@@ -457,6 +486,40 @@ export async function coreRunSearchPipeline(ctx, opts) {
     if (tolerateMissingFts) { try { pushPrompts(); } catch { /* prompt FTS may not exist in older DBs */ } } else pushPrompts();
   }
 
+  // ── Events (FTS via shared helper; events are the CANONICAL event-typed store) ──
+  if ((!effectiveSource || effectiveSource === 'events') && !isDeep) {
+    const toIso = (epoch) => (epoch ? new Date(epoch).toISOString() : null);
+    // events has no created_at ISO column (only *_epoch) and no subtitle; body carries the
+    // distilled lesson (persistHaikuSummary writes lesson_learned||narrative here), surfaced
+    // as lesson_learned (obs parity) AND text (attachBodyTokens / CLI JSON body field).
+    const shapeEvent = (r) => ({
+      source: 'event', id: r.id, type: r.event_type, title: r.title,
+      project: r.project, importance: r.importance, files_modified: r.file_paths,
+      created_at_epoch: r.created_at_epoch, created_at: toIso(r.created_at_epoch), date: toIso(r.created_at_epoch),
+      lesson_learned: r.body, text: r.body, score: r.score ?? 0, snippet: '',
+    });
+    const pushEvents = () => {
+      if (ftsQuery) {
+        const rows = searchEventsFts(db, { ftsQuery, project, projectBoost: project ? null : currentProject, epochFrom, epochTo, perSourceLimit, perSourceOffset });
+        for (const r of rows) results.push(shapeEvent(r));
+      } else if (recentListingNoFts && effectiveSource === 'events') {
+        const params = []; const wheres = ['superseded_at_epoch IS NULL'];
+        if (project) { wheres.push('project = ?'); params.push(project); }
+        if (epochFrom !== null) { wheres.push('created_at_epoch >= ?'); params.push(epochFrom); }
+        if (epochTo !== null) { wheres.push('created_at_epoch <= ?'); params.push(epochTo); }
+        params.push(perSourceLimit, perSourceOffset);
+        const rows = db.prepare(`
+          SELECT id, event_type, title, body, project, importance, file_paths, created_at_epoch
+          FROM events WHERE ${wheres.join(' AND ')}
+          ORDER BY created_at_epoch DESC
+          LIMIT ? OFFSET ?
+        `).all(...params);
+        for (const r of rows) results.push(shapeEvent(r));
+      }
+    };
+    if (tolerateMissingFts) { try { pushEvents(); } catch { /* events_fts may not exist in older DBs */ } } else pushEvents();
+  }
+
   // ── Type-list fallback (MCP): obs_type set + 0 matches → list recent of that type ──
   if (obsTypeFallback && results.length === 0 && obsType) {
     const typeWheres = ['COALESCE(compressed_into, 0) = 0', 'superseded_at IS NULL', 'type = ?'];

package/lib/stats-quality.mjs

@@ -7,6 +7,21 @@ import { notLowSignalTitleClause } from '../scoring-sql.mjs';
 import { truncate } from '../format-utils.mjs';
 import { COMPRESSED_PENDING_PURGE } from '../utils.mjs';
 
+// v3.42 F7: noise/low-signal ratios must divide by the LIVE (non-compressed) observation
+// count, NOT the all-rows total. Both numerators (lowVal, lowSignalTitle) already exclude
+// compressed rows (`compressed_into = 0`); dividing by an all-inclusive denominator
+// systematically UNDER-reports noise on a compress-heavy mature store (the store looks
+// cleaner than it is right before a maintain/compress decision). Shared by the CLI `stats`
+// and MCP `mem_stats` main gauges so the two can't drift. Returns 0 when there is no live
+// corpus (all-compressed / empty).
+export function computeNoiseGauge({ liveTotal, lowValCount, lowSignalCount }) {
+  const denom = liveTotal > 0 ? liveTotal : 0;
+  return {
+    noiseRatio: denom ? lowValCount / denom : 0,
+    lowSignalRatio: denom ? lowSignalCount / denom : 0,
+  };
+}
+
 export function computeQualityStats(db, { project, days }) {
   const projectFilter = project ? 'AND project = ?' : '';
   const baseParams = project ? [project] : [];

package/mem-cli.mjs

@@ -18,7 +18,7 @@ import { selectCompressionCandidates, groupByProjectWeek, compressGroup } from '
 import { buildNotLowSignalSql } from './lib/low-signal-patterns.mjs';
 import {
   cleanupBroken, decayAndMarkIdle, boostAccessed, demotePinned, mergeDuplicates,
-  recoverOrphanedChildren, recoverBuriedLessons,
+  recoverOrphanedChildren, recoverBuriedLessons, sweepDeferredWorkOrphans,
   purgeStale, purgeStalePreview, findDuplicates, maintenanceStats, rebuildVectors, vacuum,
   recoverChildrenOf, hardDeleteCandidateCount,
   OP_CAP, STALE_AGE_MS, PINNED_INJ_THRESHOLD,
@@ -40,6 +40,8 @@ import { readFileSync, existsSync, readdirSync } from 'fs';
 import { parseArgs, out, fail, relativeTime, fmtDateShort, parseIdToken, formatProbeHints, rejectBareStringFlags, suggestUnknownFlags, OBS_TIME_FIELDS, formatObsFieldValue } from './cli/common.mjs';
 import { saveObservation } from './lib/save-observation.mjs';
 import { rebuildObservationDerived } from './lib/observation-write.mjs';
+import { EXPORT_COLUMNS_SQL } from './lib/export-columns.mjs';
+import { computeNoiseGauge } from './lib/stats-quality.mjs';
 import { recallByFile } from './lib/recall-core.mjs';
 import { resolveAnchorToken, formatAnchorError, resolveQueryAnchor, fetchRecentTimeline, fetchTimelineWindow } from './lib/timeline-core.mjs';
 import { buildSearchFtsQuery, parseDateBounds, parseDuration, coreRunSearchPipeline } from './lib/search-core.mjs';
@@ -133,8 +135,8 @@ async function cmdSearch(db, args, { llm } = {}) {
     process.stderr.write('[mem] Note: --rerank requires --deep (it reranks deep-search candidates); ignored\n');
   }
 
-  if (source && !['observations', 'sessions', 'prompts'].includes(source)) {
-    fail(`[mem] Invalid --source "${source}". Use: observations, sessions, prompts`);
+  if (source && !['observations', 'sessions', 'prompts', 'events'].includes(source)) {
+    fail(`[mem] Invalid --source "${source}". Use: observations, sessions, prompts, events`);
     return;
   }
 
@@ -242,7 +244,7 @@ async function cmdSearch(db, args, { llm } = {}) {
 
   // "N of M" total when paged < total (paired-path with server.mjs formatSearchOutput, #8198).
   const showTime = sort === 'time';
-  const hasMixed = paged.some(r => r.source === 'session' || r.source === 'prompt');
+  const hasMixed = paged.some(r => r.source === 'session' || r.source === 'prompt' || r.source === 'event');
   // Suppressed when --or was explicit — user already asked for OR, no "fallback" there.
   const fallbackHint = orFallbackFired && !useOr ? ' (relaxed AND→OR)' : '';
 
@@ -288,7 +290,7 @@ async function cmdSearch(db, args, { llm } = {}) {
   const countLabel = total > paged.length ? `${paged.length} of ${total}` : `${paged.length}`;
   // Pluralize on total — "Found 1 of 44 result" reads wrong; the population (44) drives
   // grammatical number, not the page slice (1).
-  out(`[mem] Found ${countLabel} result${total !== 1 ? 's' : ''} for "${query}"${fallbackHint}:${hasMixed ? ' (# observation, S# session, P# prompt)' : ''}`);
+  out(`[mem] Found ${countLabel} result${total !== 1 ? 's' : ''} for "${query}"${fallbackHint}:${hasMixed ? ' (# observation, S# session, P# prompt, E# event)' : ''}`);
   // `~Nt` = est. tokens to fetch this row's full body via mem_get (attachBodyTokens, paired with
   // MCP). Conditional so a row that skipped enrichment renders cleanly, not "~undefinedt".
   const tok = r => (r.bodyTokens ? ` ~${r.bodyTokens}t` : '');
@@ -300,6 +302,12 @@ async function cmdSearch(db, args, { llm } = {}) {
     } else if (r.source === 'prompt') {
       const date = fmtDateShort(r.created_at);
       out(`P#${r.id} 💬 ${date}${timeStr} ${truncate(r.prompt_text || '(empty)', 80)}${tok(r)}`);
+    } else if (r.source === 'event') {
+      const date = fmtDateShort(r.created_at);
+      out(`E#${r.id} ${typeIcon(r.type)} ${date}${timeStr} ${truncate(r.title || '(untitled)', 80)}${tok(r)}`);
+      if (r.lesson_learned) {
+        out(`  -> ${truncate(r.lesson_learned, 80)}`);
+      }
     } else {
       const date = fmtDateShort(r.created_at);
       const title = truncate(r.title || r.subtitle || '(untitled)', 80);
@@ -1133,7 +1141,6 @@ async function cmdStats(db, args) {
       AND COALESCE(compressed_into, 0) = 0
       AND created_at_epoch < ? ${projectFilter}
   `).get(thirtyDaysAgo, ...baseParams);
-  const noiseRatio = obsTotal.c > 0 ? lowVal.c / obsTotal.c : 0;
   // Low-signal-title population: template / tool-log titles (Modified, Worked on,
   // Error while working, Error:, node/npm/npx …) that the retrieval layer already
   // filters out by default. The imp=1 "Low-value" metric above structurally can't
@@ -1145,7 +1152,13 @@ async function cmdStats(db, args) {
     WHERE NOT ${buildNotLowSignalSql()}
       AND COALESCE(compressed_into, 0) = 0 ${projectFilter}
   `).get(...baseParams);
-  const lowSignalRatio = obsTotal.c > 0 ? lowSignalTitle.c / obsTotal.c : 0;
+  // F7: both noise numerators exclude compressed rows → divide by the LIVE count, not
+  // obsTotal (all rows), so a compress-heavy store isn't reported cleaner than it is.
+  // Shared with the MCP mem_stats gauge via computeNoiseGauge (lib/stats-quality.mjs).
+  const liveTotal = db.prepare(
+    `SELECT COUNT(*) as c FROM observations WHERE COALESCE(compressed_into, 0) = 0 ${projectFilter}`
+  ).get(...baseParams);
+  const { noiseRatio, lowSignalRatio } = computeNoiseGauge({ liveTotal: liveTotal.c, lowValCount: lowVal.c, lowSignalCount: lowSignalTitle.c });
   const compressedCount = db.prepare(
     `SELECT COUNT(*) as c FROM observations WHERE compressed_into IS NOT NULL ${projectFilter}`
   ).get(...baseParams);
@@ -1677,15 +1690,12 @@ function cmdExport(db, args) {
   // content + value-signals (access/cited/uncited/injection/decay) + branch + timing.
   // `search_aliases` is an FTS5-indexed column (BM25 weight 5) — dropping it on
   // export silently lost the LLM-generated alternate query terms on restore, so a
-  // restored memory became unfindable by its aliases. 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).
+  // restored memory became unfindable by its aliases. id + memory_session_id are
+  // informational (restore remaps id and buckets under a restore session).
+  // EXPORT_COLUMNS_SQL is the single source of truth shared with the MCP mem_export
+  // tool (server.mjs) so the two export surfaces can never drift (v3.42 HIGH-2).
   const rows = db.prepare(`
-    SELECT id, memory_session_id, project, type, title, subtitle, narrative, text, concepts, facts,
-           files_read, files_modified, lesson_learned, search_aliases, importance, branch,
-           access_count, cited_count, uncited_streak, injection_count, decay_seen_count,
-           last_accessed_at, created_at, created_at_epoch
+    SELECT ${EXPORT_COLUMNS_SQL}
     FROM observations WHERE ${wheres.join(' AND ')}
     ORDER BY created_at_epoch DESC LIMIT ?
   `).all(...params, limit);
@@ -2040,6 +2050,10 @@ function cmdMaintain(db, args) {
       // lesson-bearing rows only; idempotent no-op once none remain.
       const lessonsHealed = recoverBuriedLessons(db, mctx);
       if (lessonsHealed > 0) results.push(`Healed ${lessonsHealed} lesson rows buried at importance 0`);
+      // Heal deferred_work rows whose closing obs / source prompt was hard-deleted while FK was
+      // OFF (dangling ref foreign_key_check flags). Applies the ON DELETE SET NULL the FK would.
+      const deferredHealed = sweepDeferredWorkOrphans(db, mctx);
+      if (deferredHealed > 0) results.push(`Healed ${deferredHealed} deferred-work rows with dangling references`);
     }
 
     if (ops.includes('decay')) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "3.42.0",
+  "version": "3.44.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",
@@ -68,6 +68,7 @@
     "lib/err-sampler.mjs",
     "lib/hook-telemetry.mjs",
     "lib/resolve-data-dir.mjs",
+    "lib/export-columns.mjs",
     "lib/file-intel.mjs",
     "lib/reread-guard.mjs",
     "lib/metrics.mjs",

package/project-utils.mjs

@@ -49,11 +49,19 @@ export function resolveProject(db, name) {
   ).get(`%--${name}%`);
   if (prefixed) { _cache.set(name, prefixed.project); return prefixed.project; }
 
-  // 3) Substring match: broader fallback for partial names
-  const substr = db.prepare(
-    'SELECT project FROM observations WHERE project LIKE ? GROUP BY project ORDER BY COUNT(*) DESC LIMIT 1'
-  ).get(`%${name}%`);
-  if (substr) { _cache.set(name, substr.project); return substr.project; }
+  // 3) Whole-token match: the name is a complete hyphen-delimited component of the base
+  // (e.g. "graph" → "projects--code-graph-mcp", "mcp" → "…-mcp"). Steps 1/2 already cover
+  // the exact base and the base *prefix*; this adds interior/trailing whole tokens ONLY.
+  // v3.42 F3: the old `%name%` substring fallback matched mid-token ("test" inside
+  // "loop-testing") and returned the highest-COUNT unrelated project, so `--project test`
+  // silently queried the wrong project. Require a hyphen boundary: an interior token
+  // (`%-name-%`) or a trailing token (`%-name`) so "test" no longer matches "testing".
+  const token = db.prepare(
+    `SELECT project FROM observations
+       WHERE (project LIKE '%-' || ? || '-%' OR project LIKE '%-' || ?)
+       GROUP BY project ORDER BY COUNT(*) DESC LIMIT 1`
+  ).get(name, name);
+  if (token) { _cache.set(name, token.project); return token.project; }
 
   // 4) Fallback: synthesize canonical form from current directory
   const inferred = inferProject();

package/registry-recommend.mjs

@@ -349,16 +349,29 @@ export function formatFunnel(s) {
   if (typeof s.sessions === 'number') {
     const mp = s.matched && s.matched.pass
       ? `${s.matched.adopt}/${s.matched.pass} (${(100 * s.matched.precision).toFixed(0)}%)` : 'n/a';
-    const liftRows = Object.entries(s.lift || {}).filter(([, v]) => Number.isFinite(v.lift))
+    // v3.42 F5: lift = adoptGivenPass / baseRate is a ratio over `passSessions` observations.
+    // Below LIFT_MIN_PASS_SESSIONS the numerator is 1-2 sessions of noise (a single
+    // pass→adopt yields lift 7.0 at passSessions=1) — displaying it top-ranked next to a
+    // 30-session skill misleads the shadow→live flip decision. Gate the DISPLAY on a minimum
+    // observation count and report how many were suppressed (never a silent cap).
+    const finite = Object.entries(s.lift || {}).filter(([, v]) => Number.isFinite(v.lift));
+    const shown = finite.filter(([, v]) => (v.passSessions || 0) >= LIFT_MIN_PASS_SESSIONS);
+    const suppressed = finite.length - shown.length;
+    const liftRows = shown
       .sort((a, b) => b[1].lift - a[1].lift).slice(0, 5)
       .map(([k, v]) => `${k}(lift ${v.lift.toFixed(2)}; ${v.hitSessions}/${v.passSessions} pass→adopt vs base ${(100 * v.baseRate).toFixed(0)}%)`)
       .join(', ') || '(none)';
+    const suppressNote = suppressed > 0 ? ` [${suppressed} hidden: passSessions<${LIFT_MIN_PASS_SESSIONS}]` : '';
     lines.push(`  sessions=${s.sessions}  matched precision (in-session PASS→adopt): ${mp}`);
-    lines.push(`  targeting lift (>1 = gate beats organic base rate): ${liftRows}`);
+    lines.push(`  targeting lift (>1 = gate beats organic base rate, min n=${LIFT_MIN_PASS_SESSIONS}): ${liftRows}${suppressNote}`);
   }
   return lines.join('\n');
 }
 
+// Minimum passSessions before a per-skill lift is trustworthy enough to display. Below this,
+// adoptGivenPass is computed over 1-2 sessions and the lift is noise (F5).
+export const LIFT_MIN_PASS_SESSIONS = 3;
+
 /** Human-readable threshold sweep for `registry recommend-stats --sweep`. */
 export function formatSweep(grid) {
   const lines = ['gate threshold sweep (floor × margin → pass / matched precision):'];

package/schema.mjs

@@ -104,7 +104,15 @@ export const CODE_DIR = join(homedir(), '.claude-mem-lite');
 // previously-uncited obs (see applyCitationDecay). REAL new column, so unlike v38-v40
 // this DOES advance LATEST_MIGRATION_COLUMN (→ observations.last_cited_session_id);
 // existing DBs reach the ALTER because version 40 != 41 falls through the fast-path.
-export const CURRENT_SCHEMA_VERSION = 41;
+// v42 (events_fts self-heal): events_fts was the one FTS table outside ensureFTS's
+// column-aware recreation (its DDL is non-standard — UNINDEXED cols + custom tokenizer +
+// events_fts_* trigger names — so it can't use the generic ensureFTS). Adds a dedicated
+// ensureEventsFTS run in the migration body so a future events column addition self-heals
+// instead of leaving a stale narrow index whose (wider) triggers throw "no column" and
+// silently drop event writes. NO new column, so LATEST_MIGRATION_COLUMN is unchanged — the
+// forced pass alone carries it (same pattern as v35/v36/v38/v39/v40); existing DBs run it
+// because version 41 != 42 falls through the fast-path.
+export const CURRENT_SCHEMA_VERSION = 42;
 
 // 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
@@ -555,6 +563,12 @@ export function initSchema(db) {
     END;
   `);
 
+  // v42: column-aware self-heal for events_fts (the one FTS table the generic ensureFTS can't
+  // manage — UNINDEXED cols + custom tokenizer + events_fts_* triggers). The CREATE ... IF NOT
+  // EXISTS above never widens a drifted (older, narrower) events_fts; this drops+recreates it on
+  // column drift and repopulates. No-op on a healthy DB.
+  ensureEventsFTS(db);
+
   // Observation files junction table for normalized file lookups (replaces LIKE scans on files_modified JSON)
   db.exec(`
     CREATE TABLE IF NOT EXISTS observation_files (
@@ -1067,3 +1081,65 @@ export function ensureFTS(db, ftsName, tableName, columns) {
     } catch { /* non-critical — index repopulates lazily on next write */ }
   }
 }
+
+// Column-aware self-heal for events_fts — the events table's FTS index. events_fts is NOT
+// managed by the generic ensureFTS() above because its DDL is non-standard: event_type and
+// project are UNINDEXED, it uses a custom unicode61 tokenizer with '_-' tokenchars, and its
+// triggers are named events_fts_* (not events_*). Routing it through ensureFTS would recreate
+// it WITHOUT the UNINDEXED cols / tokenizer AND install a SECOND, differently-named trigger set
+// (events_*) that double-writes the index. This dedicated guard mirrors ensureFTS's drift
+// detection while preserving the exact events_fts DDL (schema.mjs events block) — closing the
+// F8/P2-4 gap: events_fts was the one FTS table outside self-heal, so a future events column
+// addition would leave a stale narrow index whose (wider) triggers throw "no column" and
+// silently drop event writes. Idempotent: a no-op once the column set matches.
+const EVENTS_FTS_COLUMNS = ['title', 'body', 'event_type', 'project']; // full set (drift check)
+export function ensureEventsFTS(db) {
+  const ftsRow = db.prepare(`SELECT 1 FROM sqlite_master WHERE type='table' AND name='events_fts'`).get();
+  let recreated = false;
+  if (ftsRow) {
+    let existingCols = [];
+    try { existingCols = db.prepare(`PRAGMA table_info(events_fts)`).all().map(c => c.name); } catch { /* unreadable → recreate */ }
+    const drifted = existingCols.length !== EVENTS_FTS_COLUMNS.length || EVENTS_FTS_COLUMNS.some(c => !existingCols.includes(c));
+    if (drifted) {
+      db.exec(`DROP TRIGGER IF EXISTS events_fts_ai`);
+      db.exec(`DROP TRIGGER IF EXISTS events_fts_ad`);
+      db.exec(`DROP TRIGGER IF EXISTS events_fts_au`);
+      db.exec(`DROP TABLE IF EXISTS events_fts`);
+      recreated = true;
+    }
+  }
+  if (!ftsRow || recreated) {
+    db.exec(`
+      CREATE VIRTUAL TABLE IF NOT EXISTS events_fts USING fts5(
+        title, body, event_type UNINDEXED, project UNINDEXED,
+        content='events', content_rowid='id',
+        tokenize="unicode61 remove_diacritics 2 tokenchars '_-'"
+      );
+    `);
+  }
+  // Triggers reinstated from the canonical template (INSERT all 4 columns; AFTER UPDATE OF the
+  // two INDEXED columns only, so non-indexed bumps don't thrash the index). IF NOT EXISTS so an
+  // unchanged definition is a no-op — byte-identical to the events block in initSchema.
+  db.exec(`
+    CREATE TRIGGER IF NOT EXISTS events_fts_ai AFTER INSERT ON events BEGIN
+      INSERT INTO events_fts(rowid, title, body, event_type, project)
+      VALUES (new.id, COALESCE(new.title,''), COALESCE(new.body,''), new.event_type, new.project);
+    END;
+    CREATE TRIGGER IF NOT EXISTS events_fts_ad AFTER DELETE 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);
+    END;
+    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)
+      VALUES (new.id, COALESCE(new.title,''), COALESCE(new.body,''), new.event_type, new.project);
+    END;
+  `);
+  if (recreated) {
+    try {
+      const cnt = db.prepare(`SELECT COUNT(*) AS c FROM events`).get();
+      if (cnt.c > 0) db.exec(`INSERT INTO events_fts(events_fts) VALUES('rebuild')`);
+    } catch { /* non-critical — index repopulates lazily on next write */ }
+  }
+}

package/scoring-sql.mjs

@@ -51,6 +51,10 @@ export const OBS_BM25 = 'bm25(observations_fts, 10, 5, 5, 3, 3, 2, 8, 5)';
 /** session_summaries_fts BM25 weights: request=5, investigated=3, learned=3, completed=3, next_steps=2, notes=1, remaining_items=1 */
 export const SESS_BM25 = 'bm25(session_summaries_fts, 5, 3, 3, 3, 2, 1, 1)';
 
+/** events_fts BM25 weights: title=5, body=2 (event_type/project are UNINDEXED — weight irrelevant).
+ *  Title-weighted like OBS/SESS so a title hit outranks a body-only hit. */
+export const EVT_BM25 = 'bm25(events_fts, 5, 2)';
+
 /** FTS5 columns for observations (must match BM25 weight order) */
 export const OBS_FTS_COLUMNS = ['title', 'subtitle', 'narrative', 'text', 'facts', 'concepts', 'lesson_learned', 'search_aliases'];
 

package/search-engine.mjs

@@ -35,6 +35,15 @@ const SIMPLE_SCORE = `${OBS_BM25}
   * (0.5 + 0.5 * COALESCE(o.importance, 1))
   * (1.0 + 0.3 * (o.lesson_learned IS NOT NULL AND o.lesson_learned NOT IN ('', 'none')))`;
 
+// Shared column set for fetching an observation surfaced by the vector arm — used by BOTH
+// the RRF-merge branch (FTS also had results) and the FTS-empty fallback branch. Single
+// source so the two can't drift. v3.42 F4: the fallback branch's SELECT had dropped
+// lesson_learned while its RRF twin kept it, so a vector-only hit returned
+// lesson_learned: undefined — losing the lesson content AND the 1.5× lesson scoring boost
+// downstream. Both branches build `{ …, date: obs.created_at, lesson_learned: obs.lesson_learned }`
+// so the SELECT must carry created_at + lesson_learned.
+export const VEC_HIT_OBS_COLS = 'id, type, title, subtitle, project, created_at, created_at_epoch, importance, files_modified, branch, lesson_learned';
+
 export function buildObsFtsQuery(scoring, { multiplier, withSnippet, withOffset, includeNoise } = {}) {
   const scoreExpr = scoring === 'full' ? FULL_SCORE : SIMPLE_SCORE;
   const mult = multiplier ? ` * ${multiplier}` : '';
@@ -158,6 +167,24 @@ export function countPromptFtsMatches(db, { ftsQuery, project = null, epochFrom
   } catch { return 0; }
 }
 
+export function countEventFtsMatches(db, { ftsQuery, project = null, epochFrom = null, epochTo = null }) {
+  if (!ftsQuery) return 0;
+  try {
+    const wheres = ['events_fts MATCH ?', 'e.superseded_at_epoch IS NULL'];
+    const params = [ftsQuery];
+    if (project) { wheres.push('e.project = ?'); params.push(project); }
+    if (epochFrom) { wheres.push('e.created_at_epoch >= ?'); params.push(epochFrom); }
+    if (epochTo) { wheres.push('e.created_at_epoch <= ?'); params.push(epochTo); }
+    const row = db.prepare(`
+      SELECT COUNT(*) as c
+      FROM events_fts
+      JOIN events e ON events_fts.rowid = e.id
+      WHERE ${wheres.join(' AND ')}
+    `).get(...params);
+    return row?.c ?? 0;
+  } catch { return 0; }
+}
+
 /**
  * Sum true match counts across the sources that contribute to a cross-source (or
  * source-restricted) search. `obsFtsQuery` lets callers pass the OR-relaxed query
@@ -178,6 +205,9 @@ export function countSearchTotal(db, {
   if (!effectiveSource || effectiveSource === 'prompts') {
     total += countPromptFtsMatches(db, { ftsQuery, project, epochFrom, epochTo });
   }
+  if (!effectiveSource || effectiveSource === 'events') {
+    total += countEventFtsMatches(db, { ftsQuery, project, epochFrom, epochTo });
+  }
   return total;
 }
 
@@ -226,6 +256,8 @@ export function attachBodyTokens(db, results) {
       parts = [r.title, r.subtitle, r.lesson_learned, row.narrative, row.facts, row.text];
     } else if (src === 'session') {
       parts = [r.request, r.completed, r.working_on];
+    } else if (src === 'event') {
+      parts = [r.title, r.lesson_learned];   // events carry title + body(=lesson_learned) on the row
     } else {
       parts = [r.text, r.prompt_text];
     }
@@ -432,7 +464,7 @@ export function searchObservationsHybrid(db, ctx) {
       const resultMap = new Map(results.map(r => [r.id, r]));
       for (const vr of vecResults) {
         if (!resultMap.has(vr.id)) {
-          const obs = db.prepare('SELECT id, type, title, subtitle, project, created_at, created_at_epoch, importance, files_modified, branch, lesson_learned FROM observations WHERE id = ?').get(vr.id);
+          const obs = db.prepare(`SELECT ${VEC_HIT_OBS_COLS} FROM observations WHERE id = ?`).get(vr.id);
           if (!obs) continue;
           if (epochFrom !== null && obs.created_at_epoch < epochFrom) continue;
           if (epochTo !== null && obs.created_at_epoch > epochTo) continue;
@@ -450,7 +482,7 @@ export function searchObservationsHybrid(db, ctx) {
     } else {
       // FTS5 found nothing but vector found results
       for (const vr of vecResults) {
-        const obs = db.prepare('SELECT id, type, title, subtitle, project, created_at, created_at_epoch, importance, files_modified, branch FROM observations WHERE id = ?').get(vr.id);
+        const obs = db.prepare(`SELECT ${VEC_HIT_OBS_COLS} FROM observations WHERE id = ?`).get(vr.id);
         if (!obs) continue;
         if (epochFrom !== null && obs.created_at_epoch < epochFrom) continue;
         if (epochTo !== null && obs.created_at_epoch > epochTo) continue;

package/server.mjs

@@ -17,7 +17,7 @@ import { resolveAnchorToken, formatAnchorError, resolveQueryAnchor, fetchRecentT
 import { buildSearchFtsQuery, parseDateBounds, parseDuration, coreRunSearchPipeline } from './lib/search-core.mjs';
 import {
   cleanupBroken, decayAndMarkIdle, boostAccessed, demotePinned, mergeDuplicates,
-  recoverOrphanedChildren, recoverBuriedLessons,
+  recoverOrphanedChildren, recoverBuriedLessons, sweepDeferredWorkOrphans,
   purgeStale, purgeStalePreview, findDuplicates, maintenanceStats, rebuildVectors, vacuum,
   recoverChildrenOf, hardDeleteCandidateCount,
   OP_CAP, STALE_AGE_MS,
@@ -44,6 +44,8 @@ import { searchResources } from './registry-retriever.mjs';
 import { probeOtherSources as probeIdSources, bucketIdTokens } from './lib/id-routing.mjs';
 import { saveObservation } from './lib/save-observation.mjs';
 import { rebuildObservationDerived } from './lib/observation-write.mjs';
+import { EXPORT_COLUMNS_SQL } from './lib/export-columns.mjs';
+import { computeNoiseGauge } from './lib/stats-quality.mjs';
 import { recallByFile } from './lib/recall-core.mjs';
 import { AUTO_MERGE_THRESHOLD } from './lib/dedup-constants.mjs';
 import {
@@ -216,7 +218,7 @@ function formatSearchOutput(paginatedResults, args, ftsQuery, totalCount, orFall
   const countLabel = totalCount > paginatedResults.length
     ? `${paginatedResults.length} of ${totalCount}`
     : `${paginatedResults.length}`;
-  const hasMixed = paginatedResults.some(r => r.source === 'session' || r.source === 'prompt');
+  const hasMixed = paginatedResults.some(r => r.source === 'session' || r.source === 'prompt' || r.source === 'event');
   // P2-6: empty/omitted query falls through to a "listing recent" path — label it explicitly
   // so callers don't mistake BM25-less results for relevance-ranked ones.
   const qLabel = args.query ? ` for "${args.query}"` : ' (no query — listing recent)';
@@ -224,7 +226,7 @@ function formatSearchOutput(paginatedResults, args, ftsQuery, totalCount, orFall
   // query actually matched only a subset of the terms. Suppressed when the caller
   // explicitly requested OR semantics — there's no "fallback" in that path.
   const fallbackHint = orFallbackFired && !args.or ? ' (relaxed AND→OR)' : '';
-  lines.push(`Found ${countLabel} result(s)${qLabel}${fallbackHint}:${hasMixed ? ' (# observation, S# session, P# prompt)' : ''}\n`);
+  lines.push(`Found ${countLabel} result(s)${qLabel}${fallbackHint}:${hasMixed ? ' (# observation, S# session, P# prompt, E# event)' : ''}\n`);
 
   // `~Nt` = estimated tokens to fetch this row's full body via mem_get (attachBodyTokens).
   // Conditional so a result that skipped enrichment renders cleanly, not "~undefinedt".
@@ -239,6 +241,8 @@ function formatSearchOutput(paginatedResults, args, ftsQuery, totalCount, orFall
       lines.push(`S#${r.id} 📋 ${truncate(r.request || r.completed || '(no summary)')} | ${r.project} | ${fmtDate(r.date)}${tok(r)}`);
     } else if (r.source === 'prompt') {
       lines.push(`P#${r.id} 💬 ${truncate(r.text)} | ${fmtDate(r.date)}${tok(r)}`);
+    } else if (r.source === 'event') {
+      lines.push(`E#${r.id} ${typeIcon(r.type)} [${r.type}] ${truncate(r.title || '(untitled)')} | ${r.project} | ${fmtDate(r.date)}${tok(r)}`);
     }
   }
 
@@ -251,15 +255,14 @@ function formatSearchOutput(paginatedResults, args, ftsQuery, totalCount, orFall
 // Exported for tests: runs the full mem_search pipeline against an explicit db
 // with an optional injected llm (deepSearch dependency). The MCP tool handler
 // calls this with the module db and the default llm.
-// NOTE: resolveProject() inside runSearchPipeline closes over the module-level `db`,
-// not the injected one. Tests that pass a project: arg via this seam will trigger
-// resolveProject() against the real (module) DB, not the test DB.
+// v3.42 F3: resolveProject now runs against the injected `db` param (not the module db), so
+// a project: arg through this seam resolves against the TEST db — real test isolation.
 export async function handleSearchForTest(db, args, { llm, rerankLlm } = {}) {
   return runSearchPipeline(db, args, { llm, rerankLlm });
 }
 
 async function runSearchPipeline(db, args, { llm, rerankLlm } = {}) {
-  if (args.project) args = { ...args, project: resolveProject(args.project) };
+  if (args.project) args = { ...args, project: _resolveProjectShared(db, args.project) };
   const limit = args.limit ?? 20;
   const offset = args.offset ?? 0;
   // args.or: force OR from the start (CLI `search --or` parity). The default path
@@ -352,15 +355,15 @@ server.registerTool(
 
 // ─── Tool: mem_recent ────────────────────────────────────────────────────────
 
-// In-process test seam (mirrors handleSearchForTest, #8743): threads an injected
-// db through the SAME body the registered handler runs. NOTE: a `project` arg is
-// still resolved via resolveProject() against the MODULE db, not the injected one.
+// In-process test seam (mirrors handleSearchForTest, #8743): threads an injected db through
+// the SAME body the registered handler runs. v3.42 F3: a `project` arg now resolves against
+// the injected db (not the module db), so :memory: test isolation is actually achieved.
 export async function handleRecentForTest(db, args) {
   return runRecent(db, args);
 }
 
 async function runRecent(db, args) {
-  if (args.project) args = { ...args, project: resolveProject(args.project) };
+  if (args.project) args = { ...args, project: _resolveProjectShared(db, args.project) };
   const limit = args.limit ?? 10;
   const project = args.project || inferProject();
 
@@ -906,7 +909,6 @@ server.registerTool(
         AND created_at_epoch < ? ${projectFilter}
     `).get(thirtyDaysAgo, ...baseParams);
 
-    const noiseRatio = obsTotal.c > 0 ? lowVal.c / obsTotal.c : 0;
     // Low-signal-title population (template / tool-log titles the read-side filter
     // already excludes). The imp=1 "Low-value" metric can't see these, so the
     // gauge under-reports real noise without it. See lib/low-signal-patterns.mjs.
@@ -915,7 +917,12 @@ server.registerTool(
       WHERE NOT ${buildNotLowSignalSql()}
         AND COALESCE(compressed_into, 0) = 0 ${projectFilter}
     `).get(...baseParams);
-    const lowSignalRatio = obsTotal.c > 0 ? lowSignalTitle.c / obsTotal.c : 0;
+    // F7: both noise numerators exclude compressed rows → divide by the LIVE count, not
+    // obsTotal (all rows), so a compress-heavy store isn't reported cleaner than it is.
+    const liveTotal = db.prepare(
+      `SELECT COUNT(*) as c FROM observations WHERE COALESCE(compressed_into, 0) = 0 ${projectFilter}`
+    ).get(...baseParams);
+    const { noiseRatio, lowSignalRatio } = computeNoiseGauge({ liveTotal: liveTotal.c, lowValCount: lowVal.c, lowSignalCount: lowSignalTitle.c });
     const compressedCount = db.prepare(`
       SELECT COUNT(*) as c FROM observations WHERE compressed_into IS NOT NULL ${projectFilter}
     `).get(...baseParams);
@@ -1153,6 +1160,10 @@ server.registerTool(
           // lesson-bearing rows only; idempotent no-op once none remain.
           const lessonsHealed = recoverBuriedLessons(db, mctx);
           if (lessonsHealed > 0) results.push(`Healed ${lessonsHealed} lesson rows buried at importance 0`);
+          // Heal deferred_work rows whose closing obs / source prompt was deleted while FK was
+          // OFF (dangling ref foreign_key_check flags). Applies the ON DELETE SET NULL the FK would.
+          const deferredHealed = sweepDeferredWorkOrphans(db, mctx);
+          if (deferredHealed > 0) results.push(`Healed ${deferredHealed} deferred-work rows with dangling references`);
         }
 
         if (ops.includes('decay')) {
@@ -1622,52 +1633,64 @@ server.registerTool(
 
 // ─── Tool: mem_export ────────────────────────────────────────────────────────
 
+// In-process test seam (mirrors handleRecentForTest, #8743): threads an injected db
+// through the SAME body the registered handler runs. NOTE: a `project` arg is still
+// resolved via resolveProject() against the MODULE db, not the injected one.
+export async function handleExportForTest(db, args) {
+  return runExport(db, args);
+}
+
+async function runExport(db, args) {
+  const wheres = [];
+  const params = [];
+  if (!args.include_compressed) wheres.push('COALESCE(compressed_into, 0) = 0');
+  wheres.push('superseded_at IS NULL');
+  if (args.project) { wheres.push('project = ?'); params.push(_resolveProjectShared(db, args.project)); }
+  if (args.type) { wheres.push('type = ?'); params.push(args.type); }
+  // T3-P1-A: surface invalid dates instead of silently dropping the filter — mirrors
+  // mem_search, which threw. A dropped filter can quietly expand the export blast radius.
+  if (args.date_from) {
+    const epoch = new Date(args.date_from).getTime();
+    if (isNaN(epoch)) throw new Error(`Invalid date_from: "${args.date_from}" (use ISO 8601 or YYYY-MM-DD)`);
+    wheres.push('created_at_epoch >= ?');
+    params.push(epoch);
+  }
+  if (args.date_to) {
+    const d = args.date_to.length === 10 ? args.date_to + 'T23:59:59.999Z' : args.date_to;
+    const epoch = new Date(d).getTime();
+    if (isNaN(epoch)) throw new Error(`Invalid date_to: "${args.date_to}" (use ISO 8601 or YYYY-MM-DD)`);
+    wheres.push('created_at_epoch <= ?');
+    params.push(epoch);
+  }
+
+  const where = wheres.length > 0 ? 'WHERE ' + wheres.join(' AND ') : '';
+  const exportLimit = Math.min(args.limit ?? 200, 1000);
+  // T3-P2-B: probe limit+1 so we can tell "user hit their own limit with more waiting" from
+  // "user got exactly what existed". Trim to exportLimit before rendering.
+  // EXPORT_COLUMNS_SQL: shared with CLI cmdExport — the full round-trippable set restore
+  // reads back (v3.42 HIGH-2: this handler used to carry a narrower 16-col SELECT, silently
+  // dropping text/aliases/citation-signals on the advertised MCP backup→restore flow).
+  const probed = db.prepare(`SELECT ${EXPORT_COLUMNS_SQL} FROM observations ${where} ORDER BY created_at_epoch DESC LIMIT ?`).all(...params, exportLimit + 1);
+  const rows = probed.slice(0, exportLimit);
+  const moreAvailable = probed.length > exportLimit;
+
+  if (rows.length === 0) return { content: [{ type: 'text', text: 'No observations found matching the criteria.' }] };
+
+  const output = args.format === 'jsonl'
+    ? rows.map(r => JSON.stringify(r)).join('\n')
+    : JSON.stringify(rows, null, 2);
+
+  const cap = moreAvailable ? `\nNote: Results capped at ${exportLimit}. Use date_from/date_to or increase limit (max 1000) to export more.` : '';
+  return { content: [{ type: 'text', text: `Exported ${rows.length} observations:${cap}\n${output}` }] };
+}
+
 server.registerTool(
   'mem_export',
   {
     description: descriptionOf('mem_export'),
     inputSchema: memExportSchema,
   },
-  safeHandler(async (args) => {
-    const wheres = [];
-    const params = [];
-    if (!args.include_compressed) wheres.push('COALESCE(compressed_into, 0) = 0');
-    wheres.push('superseded_at IS NULL');
-    if (args.project) { wheres.push('project = ?'); params.push(resolveProject(args.project)); }
-    if (args.type) { wheres.push('type = ?'); params.push(args.type); }
-    // T3-P1-A: surface invalid dates instead of silently dropping the filter — mirrors
-    // mem_search, which threw. A dropped filter can quietly expand the export blast radius.
-    if (args.date_from) {
-      const epoch = new Date(args.date_from).getTime();
-      if (isNaN(epoch)) throw new Error(`Invalid date_from: "${args.date_from}" (use ISO 8601 or YYYY-MM-DD)`);
-      wheres.push('created_at_epoch >= ?');
-      params.push(epoch);
-    }
-    if (args.date_to) {
-      const d = args.date_to.length === 10 ? args.date_to + 'T23:59:59.999Z' : args.date_to;
-      const epoch = new Date(d).getTime();
-      if (isNaN(epoch)) throw new Error(`Invalid date_to: "${args.date_to}" (use ISO 8601 or YYYY-MM-DD)`);
-      wheres.push('created_at_epoch <= ?');
-      params.push(epoch);
-    }
-
-    const where = wheres.length > 0 ? 'WHERE ' + wheres.join(' AND ') : '';
-    const exportLimit = Math.min(args.limit ?? 200, 1000);
-    // T3-P2-B: probe limit+1 so we can tell "user hit their own limit with more waiting" from
-    // "user got exactly what existed". Trim to exportLimit before rendering.
-    const probed = db.prepare(`SELECT id, project, type, title, subtitle, narrative, concepts, facts, lesson_learned, importance, files_modified, branch, access_count, memory_session_id, created_at, created_at_epoch FROM observations ${where} ORDER BY created_at_epoch DESC LIMIT ?`).all(...params, exportLimit + 1);
-    const rows = probed.slice(0, exportLimit);
-    const moreAvailable = probed.length > exportLimit;
-
-    if (rows.length === 0) return { content: [{ type: 'text', text: 'No observations found matching the criteria.' }] };
-
-    const output = args.format === 'jsonl'
-      ? rows.map(r => JSON.stringify(r)).join('\n')
-      : JSON.stringify(rows, null, 2);
-
-    const cap = moreAvailable ? `\nNote: Results capped at ${exportLimit}. Use date_from/date_to or increase limit (max 1000) to export more.` : '';
-    return { content: [{ type: 'text', text: `Exported ${rows.length} observations:${cap}\n${output}` }] };
-  })
+  safeHandler(async (args) => runExport(db, args))
 );
 
 // ─── Tool: mem_recall ────────────────────────────────────────────────────────

package/source-files.mjs

@@ -170,6 +170,10 @@ export const SOURCE_FILES = [
   // mem-cli.mjs::cmdImportJsonl; listed here so source-files-sync.test.mjs
   // and the npm tarball ship it on every release.
   'lib/import-jsonl.mjs',
+  // v3.42 HIGH-2: single source of truth for the export/restore round-trippable column
+  // set. Statically imported by server.mjs (mem_export) and mem-cli.mjs (cmdExport) so the
+  // two export surfaces can't drift. Must ship or auto-update breaks export on either.
+  'lib/export-columns.mjs',
 ];
 
 /**
@@ -199,15 +203,39 @@ export const HOOK_SCRIPT_FILES = [
   'hook-launcher.mjs',
 ];
 
+// Executable scripts that are NOT direct-install hook scripts (so they don't belong in
+// HOOK_SCRIPT_FILES, which install.mjs materializes into ~/.claude-mem-lite/scripts/) but
+// ARE run at runtime and MUST be signed:
+//   - launch.mjs / launch-preflight.mjs: the plugin MCP server (.mcp.json runs
+//     ${CLAUDE_PLUGIN_ROOT}/scripts/launch.mjs; launch.mjs imports launch-preflight.mjs).
+//     install.mjs::dedupePluginCacheAndHooks copies BOTH from the tarball into every plugin
+//     cache version dir during repair() — an unsigned launcher let a release published
+//     without the signing key (reusing the real manifest+sig) swap launch.mjs and gain RCE
+//     as the MCP server. v3.42 audit HIGH-1.
+//   - setup.sh: run on plugin SessionStart via hooks.json. Signed for defense-in-depth
+//     (no tarball→executed-path propagation today, but it ships in files[] and is executed).
+// These ship via package.json files[] directly, not via HOOK_SCRIPT_FILES' copy path, so
+// listing them here changes ONLY what is signed/verified, not what install materializes.
+// Module-internal (spread into RELEASE_SIGNED_FILES below); not exported — no external
+// consumer, and the signing test asserts coverage via the built manifest, not this list.
+const LAUNCHER_SCRIPT_FILES = [
+  'launch.mjs',
+  'launch-preflight.mjs',
+  'setup.sh',
+];
+
 // The complete set of files the release signature MUST cover: every runtime .mjs
 // (SOURCE_FILES) PLUS the executable hook scripts (copyReleaseIntoStaging installs these
-// into the live dir and they run on every hook fire). HOOK_SCRIPT_FILES were historically
-// NOT in the signed manifest, so an attacker able to PUBLISH a release — but without the
-// signing key — could swap a hook script (e.g. post-tool-use.sh / hook-launcher.mjs) while
-// every SOURCE_FILES hash still matched, and fail-closed verification would still pass →
-// RCE on the next hook fire. Keys are ROOT-relative, matching the extracted-tarball layout
-// that verifyReleaseFiles hashes against.
+// into the live dir and they run on every hook fire) PLUS the launcher/setup scripts.
+// HOOK_SCRIPT_FILES were historically NOT in the signed manifest, so an attacker able to
+// PUBLISH a release — but without the signing key — could swap a hook script (e.g.
+// post-tool-use.sh / hook-launcher.mjs) while every SOURCE_FILES hash still matched, and
+// fail-closed verification would still pass → RCE on the next hook fire. The MCP launcher
+// (LAUNCHER_SCRIPT_FILES) was the same gap reopened for the plugin+repair path (v3.42
+// HIGH-1). Keys are ROOT-relative, matching the extracted-tarball layout that
+// verifyReleaseFiles hashes against.
 export const RELEASE_SIGNED_FILES = [
   ...SOURCE_FILES,
   ...HOOK_SCRIPT_FILES.map(name => `scripts/${name}`),
+  ...LAUNCHER_SCRIPT_FILES.map(name => `scripts/${name}`),
 ];

package/tool-schemas.mjs

@@ -80,7 +80,7 @@ const coerceMixedIdTokens = z.preprocess(
 
 export const memSearchSchema = {
   query: z.string().optional().describe('Search query (FTS5 syntax supported)'),
-  type: z.enum(['observations', 'sessions', 'prompts']).optional().describe('Limit to one table'),
+  type: z.enum(['observations', 'sessions', 'prompts', 'events']).optional().describe('Limit to one source table (default: all). events = the canonical bugfix/feature/decision/lesson history (auto-captured event-typed memories)'),
   obs_type: OBS_TYPE_ENUM.optional().describe('Filter observation type'),
   project: z.string().optional().describe('Filter by project name'),
   date_from: z.string().optional().describe('Start date (ISO 8601 or YYYY-MM-DD)'),

package/utils.mjs

@@ -9,7 +9,7 @@ import { buildLowSignalRegex } from './lib/low-signal-patterns.mjs';
 // ─── Re-exports from extracted modules ──────────────────────────────────────
 // Backward compatibility: all consumers import from utils.mjs
 
-export { DECAY_HALF_LIFE_BY_TYPE, DEFAULT_DECAY_HALF_LIFE_MS, OBS_BM25, SESS_BM25, TYPE_DECAY_CASE, TYPE_QUALITY_CASE, OBS_FTS_COLUMNS, notLowSignalTitleClause, noisePenaltyClause } from './scoring-sql.mjs';
+export { DECAY_HALF_LIFE_BY_TYPE, DEFAULT_DECAY_HALF_LIFE_MS, OBS_BM25, SESS_BM25, EVT_BM25, TYPE_DECAY_CASE, TYPE_QUALITY_CASE, OBS_FTS_COLUMNS, notLowSignalTitleClause, noisePenaltyClause } from './scoring-sql.mjs';
 export { cjkBigrams, extractCjkSynonymTokens, extractCjkKeywords, extractCjkLikePatterns, SYNONYM_MAP, expandToken, sanitizeFtsQuery, relaxFtsQueryToOr, FTS_STOP_WORDS, CJK_COMPOUNDS } from './nlp.mjs';
 export { resolveProject, _resetProjectCache } from './project-utils.mjs';
 export { scrubSecrets, SECRET_PATTERNS } from './secret-scrub.mjs';
@@ -323,9 +323,17 @@ export function parseJsonFromLLM(text) {
   // First balanced object — survives unfenced output wrapped in brace-containing prose.
   const balanced = firstBalancedJsonObject(text);
   if (balanced) try { return JSON.parse(balanced); } catch {}
-  // Last-resort greedy span (handles a payload that isn't the FIRST balanced object).
-  const obj = text.match(/\{[\s\S]*\}/);
-  if (obj) try { return JSON.parse(obj[0]); } catch {}
+  // Last-resort span from the first `{` to the last `}` — handles a payload that isn't the
+  // FIRST balanced object. Resolved via index scan (O(n)) rather than the greedy
+  // /\{[\s\S]*\}/, which backtracks O(n²) across k unclosed opening braces (a synthetic
+  // "{{{…" with no close made the regex O(n²); LLM outputs are bounded so it wasn't
+  // exploitable — defense in depth). Behaviorally identical: the greedy match anchors on the
+  // first `{` that has any `}` after it and, being greedy, ends at the last `}`.
+  const firstBrace = text.indexOf('{');
+  const lastBrace = text.lastIndexOf('}');
+  if (firstBrace !== -1 && lastBrace > firstBrace) {
+    try { return JSON.parse(text.slice(firstBrace, lastBrace + 1)); } catch {}
+  }
   return null;
 }
 
@@ -456,6 +464,3 @@ export function getCurrentBranch() {
   _branchCacheTime = now;
   return _cachedBranch;
 }
-
-/** Reset cached branch (for testing or after git checkout) */
-export function _resetBranchCache() { _cachedBranch = undefined; _branchCacheTime = 0; }