claude-mem-lite 3.41.0 → 3.43.0

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
   "plugins": [
     {
       "name": "claude-mem-lite",
-      "version": "3.41.0",
+      "version": "3.43.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.41.0",
+  "version": "3.43.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/lib/citation-tracker.mjs

@@ -626,9 +626,10 @@ export function applyCitationDecay(db, project, injectedIds, citedIds, sessionId
   // cite-rate reads N/2 for a single injected-then-cited obs instead of N/1.
   const updatePromote = db.prepare(`
     UPDATE observations
-       SET importance = MIN(?, importance + 1),
+       SET importance = MIN(?, COALESCE(importance, 1) + 1),
            cited_count = cited_count + 1,
            uncited_streak = 0,
+           demoted_at = NULL,
            last_decided_session_id = ?,
            last_cited_session_id = ?,
            decay_seen_count = decay_seen_count + ?
@@ -655,7 +656,7 @@ export function applyCitationDecay(db, project, injectedIds, citedIds, sessionId
   `);
   const updateDemote = db.prepare(`
     UPDATE observations
-       SET importance = MAX(?, importance - 1),
+       SET importance = MAX(?, COALESCE(importance, 1) - 1),
            uncited_streak = 0,
            last_decided_session_id = ?,
            demoted_at = ?,

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/import-jsonl.mjs

@@ -147,7 +147,11 @@ export async function importJsonl(db, path, { project }) {
     const mb = (n) => Math.round(n / (1024 * 1024));
     throw new Error(`transcript too large (${mb(st.size)}MB > ${mb(MAX_IMPORT_BYTES)}MB cap); split it (e.g. split -l 50000 into parts) and import the parts`);
   }
-  const lines = readFileSync(path, 'utf8').split('\n');
+  // Strip a leading UTF-8 BOM — Node's utf8 read leaves it on, so line 1 would become
+  // a U+FEFF-prefixed "{...}" and fail JSON.parse (silently dropped as "skipped"). Real CC
+  // are BOM-less, but an editor-touched or re-encoded file can carry one.
+  const rawText = readFileSync(path, 'utf8');
+  const lines = (rawText.charCodeAt(0) === 0xFEFF ? rawText.slice(1) : rawText).split('\n');
   const seenPrompts = new Set();
   const seenObs = new Set();
   // Pre-seed dedup sets from existing rows so a second run on the same file

package/lib/search-core.mjs

@@ -28,6 +28,7 @@ import { sanitizeFtsQuery, relaxFtsQueryToOr, SESS_BM25, DEFAULT_DECAY_HALF_LIFE
 import { cjkPrecisionOk, extractCjkLikePatterns } from '../nlp.mjs';
 import { computeTier } from '../tier.mjs';
 import { countSearchTotal, attachBodyTokens } from '../search-engine.mjs';
+import { notLowSignalTitleClause } from '../scoring-sql.mjs';
 
 /** Sanitize a user query to FTS5 syntax; optionally force OR semantics. */
 export function buildSearchFtsQuery(query, { or = false } = {}) {
@@ -459,6 +460,11 @@ export async function coreRunSearchPipeline(ctx, opts) {
   // ── 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 = ?'];
+    // Mirror the FTS path's low-signal filter (buildObsFtsQuery): this fallback is still a
+    // SEARCH surface, so degraded titles ("Modified X", "Error: …") must not lead it —
+    // acute for obs_type='change', the noise band. (The no-query recent-listing in
+    // searchObservationsHybrid deliberately does NOT filter — it mirrors mem_recent.)
+    if (!includeNoise) typeWheres.push(notLowSignalTitleClause(''));
     const typeParams = [obsType];
     if (project) { typeWheres.push('project = ?'); typeParams.push(project); }
     if (epochFrom !== null) { typeWheres.push('created_at_epoch >= ?'); typeParams.push(epochFrom); }

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

@@ -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';
@@ -1133,7 +1135,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 +1146,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);
@@ -1538,7 +1545,15 @@ function cmdUpdate(db, args) {
     }
     updates.push('title = ?'); params.push(scrubSecrets(flags.title));
   }
-  if (flags.narrative !== undefined) { updates.push('narrative = ?'); params.push(scrubSecrets(flags.narrative)); }
+  if (flags.narrative !== undefined) {
+    // Reject empty (mirror --title): an explicit '' would blank the narrative
+    // irrecoverably (update takes no snapshot). Omit the flag to leave it unchanged.
+    if (typeof flags.narrative === 'string' && flags.narrative.trim() === '') {
+      fail('[mem] --narrative cannot be empty. Omit the flag to leave it unchanged.');
+      return;
+    }
+    updates.push('narrative = ?'); params.push(scrubSecrets(flags.narrative));
+  }
   if (flags.type) {
     const validTypes = new Set(['decision', 'bugfix', 'feature', 'refactor', 'discovery', 'change']);
     if (!validTypes.has(flags.type)) {
@@ -1566,13 +1581,23 @@ function cmdUpdate(db, args) {
       fail(`[mem] --lesson too long (${rawLesson.length} chars, max 500).`);
       return;
     }
+    if (typeof rawLesson === 'string' && rawLesson.trim() === '') {
+      fail('[mem] --lesson cannot be empty. Omit the flag to leave it unchanged.');
+      return;
+    }
     updates.push('lesson_learned = ?');
     params.push(scrubSecrets(rawLesson));
   }
   // Scrub like the sibling text fields above (title/narrative/lesson) and the MCP twin
   // mem_update — concepts is a scrub-target + FTS-indexed column, so a raw secret here
   // lands searchable + exportable (rebuildObservationDerived folds it into `text`).
-  if (flags.concepts !== undefined) { updates.push('concepts = ?'); params.push(scrubSecrets(flags.concepts)); }
+  if (flags.concepts !== undefined) {
+    if (typeof flags.concepts === 'string' && flags.concepts.trim() === '') {
+      fail('[mem] --concepts cannot be empty. Omit the flag to leave it unchanged.');
+      return;
+    }
+    updates.push('concepts = ?'); params.push(scrubSecrets(flags.concepts));
+  }
 
   if (updates.length === 0) {
     fail('[mem] No fields to update. Use --title, --type, --importance, --lesson/--lesson-learned, --narrative, --concepts');
@@ -1659,15 +1684,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, 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);
@@ -1740,6 +1762,7 @@ function cmdRestore(db, argv) {
 
   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
+      text = COALESCE(?, text),
       subtitle = ?, concepts = ?, facts = ?, search_aliases = ?, files_read = ?, branch = COALESCE(?, branch),
       access_count = ?, cited_count = ?, uncited_streak = ?, injection_count = ?,
       decay_seen_count = ?, last_accessed_at = ?
@@ -1770,15 +1793,20 @@ function cmdRestore(db, argv) {
       });
       if (res.kind !== 'saved') { skipped++; continue; } // saveObservation Jaccard dedup
       // Re-apply the fields saveObservation zeros/derives so the backup is faithful.
-      // search_aliases is its own FTS5 column, so this UPDATE re-syncs the index
-      // (via the observations FTS triggers) and restored aliases stay searchable.
-      // Scrub the FTS-indexed text fields on the way in — the sibling ingest paths
-      // (import-jsonl, compress-core) scrub as defense-in-depth, and restore is the only
-      // rewrite path that skipped it. A backup made before a SECRET_PATTERNS entry existed
-      // would otherwise re-index an old secret in facts/concepts even though narrative
-      // (routed through saveObservation) gets re-scrubbed. files_read/branch are
-      // paths/identifiers, not scrub-target text — left as-is.
+      // `text` is the observation BODY and its own FTS5 column — import-jsonl / cold-start
+      // rows keep the body there with an empty narrative, so saveObservation (content =
+      // narrative || title) would collapse it to the bare title. COALESCE re-applies the
+      // exported body (NULL when absent → keep saveObservation's derived text, so old
+      // backups without the column degrade gracefully). search_aliases is its own FTS5
+      // column too, so this UPDATE re-syncs the index (via the observations FTS triggers)
+      // and restored body/aliases stay searchable. Scrub the FTS-indexed text fields on
+      // the way in — the sibling ingest paths (import-jsonl, compress-core) scrub as
+      // defense-in-depth, and restore is the only rewrite path that skipped it. A backup
+      // made before a SECRET_PATTERNS entry existed would otherwise re-index an old secret
+      // in text/facts/concepts. files_read/branch are paths/identifiers, not scrub-target
+      // text — left as-is.
       signalUpdate.run(
+        r.text ? scrubSecrets(r.text) : null,
         scrubSecrets(r.subtitle || ''), scrubSecrets(r.concepts || ''), scrubSecrets(r.facts || ''),
         r.search_aliases === null || r.search_aliases === undefined ? null : scrubSecrets(r.search_aliases),
         r.files_read || '[]', r.branch ?? null,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "3.41.0",
+  "version": "3.43.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/registry.mjs

@@ -390,11 +390,16 @@ const UPSERT_SQL = `
     capability_summary=CASE WHEN excluded.capability_summary != '' THEN excluded.capability_summary ELSE capability_summary END,
     input_type=CASE WHEN excluded.input_type != '' THEN excluded.input_type ELSE input_type END,
     output_type=CASE WHEN excluded.output_type != '' THEN excluded.output_type ELSE output_type END,
-    prerequisites=excluded.prerequisites,
+    -- Preserve-on-empty (same class as the FTS text columns above): a partial re-import
+    -- omits prerequisites/complexity, so upsertResource supplies their DEFAULTS ('{}' /
+    -- 'intermediate'). No CLI flag sets these (only a full re-index does), so treating the
+    -- default as the "absent" sentinel is safe: a real re-index sends non-default values,
+    -- which still overwrite; a metadata edit sends the default, which now preserves.
+    prerequisites=CASE WHEN excluded.prerequisites NOT IN ('', '{}') THEN excluded.prerequisites ELSE prerequisites END,
     keywords=CASE WHEN excluded.keywords != '' THEN excluded.keywords ELSE keywords END,
     tech_stack=CASE WHEN excluded.tech_stack != '' THEN excluded.tech_stack ELSE tech_stack END,
     use_cases=CASE WHEN excluded.use_cases != '' THEN excluded.use_cases ELSE use_cases END,
-    complexity=excluded.complexity,
+    complexity=CASE WHEN excluded.complexity NOT IN ('', 'intermediate') THEN excluded.complexity ELSE complexity END,
     indexed_at=excluded.indexed_at, updated_at=datetime('now')
 `;
 

package/search-engine.mjs

@@ -27,13 +27,22 @@ const FULL_SCORE = `${OBS_BM25}
   * (CASE WHEN ? IS NOT NULL AND o.project = ? THEN 2.0 ELSE 1.0 END)
   * (0.5 + 0.5 * COALESCE(o.importance, 1))
   * (1.0 + 0.1 * LN(1 + COALESCE(o.access_count, 0)))
-  * (1.0 + 0.3 * (o.lesson_learned IS NOT NULL))`;
+  * (1.0 + 0.3 * (o.lesson_learned IS NOT NULL AND o.lesson_learned NOT IN ('', 'none')))`;
 
 const SIMPLE_SCORE = `${OBS_BM25}
   * (1.0 + EXP(-0.693 * MAX(0, ? - MAX(o.created_at_epoch, COALESCE(o.last_accessed_at, o.created_at_epoch))) / ${TYPE_DECAY_CASE}))
   * ${TYPE_QUALITY_CASE}
   * (0.5 + 0.5 * COALESCE(o.importance, 1))
-  * (1.0 + 0.3 * (o.lesson_learned IS NOT NULL))`;
+  * (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;
@@ -432,7 +441,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 +459,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/secret-scrub.mjs

@@ -44,6 +44,11 @@ export const SECRET_PATTERNS = [
   // low-FP decision that `topsecret=` / `access_token_count:` are non-credentials
   // (#8283 + utils.test.mjs:1089-1100); bare `pwd` is omitted so `PWD=` (a path) survives.
   [/((?:\b|_)(?:api[_-]?key|api[_-]?secret|secret[_-]?key|access[_-]?key|private[_-]?key|client[_-]?secret|auth[_-]?token|access[_-]?token|refresh[_-]?token|pgpassword|pgpass|mysql_pwd)\s*[=:]\s*)(?!process\.env\.)(?!new\s)(?!\w+\()(?!(?:null|undefined|true|false|None|nil|empty|""|''|0)\b)[^\s,;'"}\]]{6,}/gi, '$1***'],
+  // Space-separated credential CLI flag: `--password <value>` (long-form). The KV
+  // patterns above require `=`/`:`; the shell long-flag form uses a space. Long-form
+  // only — `-p`/`-u` short flags collide with unit/user/update flags (too FP-risky).
+  // `(?!-)` stops it eating a following `--flag` when --password has no value.
+  [/(--(?:password|passwd)[=\s]+)(?!-)[^\s'"]{6,}/gi, '$1***'],
   // Bare-key QUOTED values — `api_key="..."`, `password: '...'`. The unquoted KV
   // patterns above stop at `'`/`"` (excluded from their value class), so a quoted
   // value matched 0 chars and slipped through. Consumes the opening quote, the value,
@@ -68,35 +73,46 @@ export const SECRET_PATTERNS = [
   [/\bsk-(?:proj|ant|ant-api\d{2})-[a-zA-Z0-9_-]{8,}\b/g, '***'],
   [/\bsk-[a-zA-Z0-9_-]{20,}\b/g, '***'],
   // GitHub tokens (ghp_, gho_, github_pat_)
-  [/\b(?:ghp_|gho_|ghs_|ghr_)[a-zA-Z0-9_]{30,}\b/g, '***'],
+  [/\b(?:ghp_|gho_|ghs_|ghr_|ghu_)[a-zA-Z0-9_]{30,}\b/g, '***'],
   [/\bgithub_pat_[a-zA-Z0-9_]{22,}\b/g, '***'],
   // GitLab tokens (glpat-)
   [/\bglpat-[a-zA-Z0-9_-]{20,}\b/g, '***'],
-  // Slack tokens (xox[bpas]-)
-  [/\bxox[bpas]-[a-zA-Z0-9-]{10,}\b/g, '***'],
+  // Slack tokens (xox[bpasr]-, xapp-, xoxe-)
+  [/\b(?:xox[bpasr]|xapp|xoxe)-[a-zA-Z0-9-]{10,}\b/g, '***'],
+  // Slack incoming-webhook URL — the path after /services/ is the shared secret.
+  [/(https:\/\/hooks\.slack\.com\/services\/)[A-Za-z0-9/]+/g, '$1***'],
   // JWT tokens (eyJ...eyJ...)
   [/\beyJ[a-zA-Z0-9_-]{10,}\.eyJ[a-zA-Z0-9_-]{10,}\.[a-zA-Z0-9_-]+\b/g, '***'],
   // PEM private key blocks. `[A-Z0-9 ]*` covers every armor label — RSA/EC/DSA/
   // OPENSSH plus ENCRYPTED and PGP (… PRIVATE KEY BLOCK) — that the fixed
   // alternation missed; the block delimiters make FP impossible.
   [/-----BEGIN [A-Z0-9 ]*PRIVATE KEY(?: BLOCK)?-----[\s\S]*?-----END [A-Z0-9 ]*PRIVATE KEY(?: BLOCK)?-----/g, '***PEM_KEY***'],
-  // Long hex strings in assignments (e.g. SECRET_KEY=abc123def456...)
-  [/(\b(?:key|secret|token|hash)\s*[=:]\s*)[0-9a-f]{32,}\b/gi, '$1***'],
+  // Long hex strings in credential assignments (e.g. SECRET_KEY=abc123def456...).
+  // `hash` deliberately excluded: `hash: <40hex>` / `hash=<md5>` are git SHAs and
+  // checksums (real, preserved data in this hash-heavy repo), not credentials.
+  [/(\b(?:key|secret|token)\s*[=:]\s*)[0-9a-f]{32,}\b/gi, '$1***'],
   // Google Cloud API keys (AIza...)
   [/\bAIza[A-Za-z0-9_-]{35}\b/g, '***'],
-  // Generic Bearer tokens in Authorization headers
-  [/(Authorization:\s*Bearer\s+)[^\s,;'"}\]]+/gi, '$1***'],
+  // Authorization header credentials — Bearer (opaque), Basic (base64 user:pass),
+  // and GitHub's `token` scheme all carry secrets after the scheme word.
+  [/(Authorization:\s*(?:Bearer|Basic|token)\s+)[^\s,;'"}\]]+/gi, '$1***'],
   // Supabase / generic long base64 keys (40+ chars, common in env vars)
   [/(\b(?:SUPABASE_KEY|SUPABASE_ANON_KEY|SUPABASE_SERVICE_ROLE_KEY|DATABASE_URL|REDIS_URL)\s*[=:]\s*)[^\s,;'"}\]]+/gi, '$1***'],
   // Basic auth in URLs (https://user:password@host). ftp/ftps added — file-drop
-  // creds are a common leak shape the https-only form missed.
-  [/(https?|ftps?):\/\/[^@/\s]+:[^@/\s]+@/gi, '$1://***:***@'],
-  // Database connection strings (postgres, mysql, mongodb, redis, amqp)
-  [/\b(postgres(?:ql)?|mysql|mongodb(?:\+srv)?|redis|amqp):\/\/[^\s,;'"}\]]+/gi, '$1://***'],
+  // creds are a common leak shape the https-only form missed. The userinfo run
+  // EXCLUDES `:` (`[^@/\s:]+`) so the two runs can't overlap on a colon — the
+  // overlapping form caused O(n²) catastrophic backtracking on a colon-heavy
+  // non-terminating input (an availability DoS on the synchronous prompt path).
+  [/(https?|ftps?):\/\/[^@/\s:]+:[^@/\s]+@/gi, '$1://***:***@'],
+  // Database connection strings (postgres, mysql, mariadb, mssql, mongodb, redis,
+  // amqp) incl. their TLS/alias variants (rediss/amqps/mssql/sqlserver) — managed
+  // cloud DBs almost always use the TLS scheme, which the base-only list leaked.
+  [/\b(postgres(?:ql)?|mysql|mariadb|mssql|sqlserver|mongodb(?:\+srv)?|rediss?|amqps?):\/\/[^\s,;'"}\]]+/gi, '$1://***'],
   // npm tokens (npm_...)
   [/\bnpm_[a-zA-Z0-9]{36,}\b/g, '***'],
-  // Stripe keys (sk_live_, rk_live_, pk_live_, sk_test_, pk_test_)
+  // Stripe keys (sk_live_, rk_live_, pk_live_, sk_test_, pk_test_) + webhook signing secret (whsec_)
   [/\b[srp]k_(?:live|test)_[a-zA-Z0-9]{20,}\b/g, '***'],
+  [/\bwhsec_[a-zA-Z0-9]{20,}\b/g, '***'],
   // SendGrid API keys: SG.<22>.<43> — two dots at fixed offsets make this
   // structurally unmistakable; near-zero false-positive risk.
   [/\bSG\.[A-Za-z0-9_-]{22}\.[A-Za-z0-9_-]{43}\b/g, '***'],

package/server.mjs

@@ -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 {
@@ -251,15 +253,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 +353,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 +907,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 +915,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);
@@ -1622,52 +1627,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

@@ -237,13 +237,15 @@ export const memUpdateSchema = {
   // CLI parity (cmdUpdate): empty/whitespace title would render as `(untitled)`
   // in every listing — reject here like the CLI does, instead of persisting it.
   title: z.string().refine(s => s.trim() !== '', 'title cannot be empty').optional().describe('New title'),
-  narrative: z.string().optional().describe('New narrative/content'),
+  // Reject empty content fields (parity with `title` above + cmdUpdate): an explicit
+  // '' would blank narrative/lesson/concepts irrecoverably (mem_update takes no snapshot).
+  narrative: z.string().refine(s => s.trim() !== '', 'narrative cannot be empty').optional().describe('New narrative/content'),
   type: OBS_TYPE_ENUM.optional().describe('New observation type'),
   importance: coerceInt.pipe(z.number().int().min(1).max(3)).optional().describe('New importance (1-3)'),
   // 500-char cap mirrors memSaveSchema + cmdUpdate — update was the one path
   // that let overlong lessons leak into the DB via MCP.
-  lesson_learned: z.string().max(500).optional().describe('Add or update lesson learned'),
-  concepts: z.string().optional().describe('Space-separated concept tags'),
+  lesson_learned: z.string().max(500).refine(s => s.trim() !== '', 'lesson_learned cannot be empty').optional().describe('Add or update lesson learned'),
+  concepts: z.string().refine(s => s.trim() !== '', 'concepts cannot be empty').optional().describe('Space-separated concept tags'),
 };
 
 export const memExportSchema = {