claude-mem-lite 3.35.2 → 3.37.0

package/hook.mjs

@@ -118,12 +118,19 @@ for (const sig of ['SIGTERM', 'SIGINT']) {
       try {
         const ep = readEpisodeRaw();
         if (ep && ep.entries && ep.entries.length > 0) {
-          // Persist a rule-based observation synchronously BEFORE writing the flush
-          // file — that file has no consumer, so this is the only thing that prevents
-          // the in-flight episode being lost on abnormal termination (audit #6).
-          saveEpisodeImmediate(ep);
-          const flushFile = join(RUNTIME_DIR, `ep-flush-${Date.now()}-${randomUUID().slice(0, 8)}.json`);
-          writeFileSync(flushFile, JSON.stringify(ep));
+          // Persist a rule-based observation synchronously — the ONLY thing that
+          // salvages the in-flight episode on abnormal termination (audit #6). A
+          // detached llm-episode child can't be spawned from a dying process, so no
+          // ep-flush-* file is written here: it would have NO consumer AND would make
+          // every later handleLLMSummary poll the full CLAUDE_MEM_FLUSH_TIMEOUT (~15s)
+          // waiting for a file that only the 24h orphan-sweep ever removes.
+          // Split by CC session first (v3.35.2 parity): the normal flush and the Stop
+          // lock-contended fallback both planEpisodeFlush, but this crash path flushed the
+          // WHOLE buffer as one observation, co-attributing two interleaved same-project
+          // sessions into one garbled row. planEpisodeFlush returns [ep] by reference when
+          // there is ≤1 CC session (the common case → identical to before), else one sub
+          // per session. Pure/sync → safe inside the signal handler.
+          for (const sub of planEpisodeFlush(ep)) saveEpisodeImmediate(sub);
           try { unlinkSync(join(RUNTIME_DIR, `ep-${inferProject()}.json`)); } catch {}
         }
       } catch {}
@@ -468,16 +475,24 @@ async function handleStop() {
         if (episode && episode.entries && episode.entries.length > 0 && episodeHasSignificantContent(episode)) {
           if (!episode.sessionId) episode.sessionId = sessionId;
           if (!episode.project) episode.project = project;
-          // Immediate save: persist rule-based observation to DB before spawning background worker.
-          // Without this, data is lost if the background worker fails.
-          try {
-            const obs = buildImmediateObservation(episode);
-            const id = saveObservation(obs, episode.project, episode.sessionId);
-            if (id) episode.savedId = id;
-          } catch (e) { debugCatch(e, 'handleStop-fallback-immediateSave'); }
-          const flushFile = join(RUNTIME_DIR, `ep-flush-${Date.now()}-${randomUUID().slice(0, 8)}.json`);
-          writeFileSync(flushFile, JSON.stringify(episode));
-          spawnBackground('llm-episode', flushFile);
+          // Split by CC session before saving — parity with flushEpisode's non-contended path
+          // (v3.35.2). Without this, the lock-contended fallback re-merged exactly the interleaved
+          // concurrent-session buffers v3.35.2 split apart, co-attributing two sessions' work into
+          // one garbled observation. planEpisodeFlush returns [episode] by reference for the common
+          // single-session case, so this is a no-op there. Immediate-save each group BEFORE its
+          // flush-file write (same ordering as flushEpisodeGroup) so a worker crash can't lose it.
+          for (const sub of planEpisodeFlush(episode)) {
+            if (!sub.sessionId) sub.sessionId = sessionId;
+            if (!sub.project) sub.project = project;
+            try {
+              const obs = buildImmediateObservation(sub);
+              const id = saveObservation(obs, sub.project, sub.sessionId);
+              if (id) sub.savedId = id;
+            } catch (e) { debugCatch(e, 'handleStop-fallback-immediateSave'); }
+            const flushFile = join(RUNTIME_DIR, `ep-flush-${Date.now()}-${randomUUID().slice(0, 8)}.json`);
+            writeFileSync(flushFile, JSON.stringify(sub));
+            spawnBackground('llm-episode', flushFile);
+          }
         }
       } finally {
         try { unlinkSync(claimFile); } catch {}

package/install.mjs

@@ -1979,30 +1979,52 @@ async function manualUpdate() {
 // latest code even when local install.mjs / hook-update.mjs are themselves
 // buggy on disk.
 async function repair() {
-  console.log('\nclaude-mem-lite repair — re-syncing from latest GitHub release\n');
+  console.log('\nclaude-mem-lite repair — re-syncing from the latest SIGNED GitHub release\n');
   const stagingDir = mkdtempSync(join(tmpdir(), 'claude-mem-lite-repair-'));
   try {
-    const tarballUrl = 'https://api.github.com/repos/sdsrss/claude-mem-lite/tarball';
+    // Resolve the latest RELEASE (tag) and cryptographically VERIFY it before running any
+    // downloaded code — parity with the auto-update path (hook-update.downloadAndInstall).
+    // The old code fetched `/tarball` (default-branch main HEAD, unreleased WIP) and ran its
+    // install.mjs UNVERIFIED, and this path is auto-triggered by hook-launcher on any
+    // ERR_MODULE_NOT_FOUND — so a drifted install silently self-healed onto main, and a
+    // 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;
+    try {
+      ({ fetchLatestRelease, verifyReleaseAuthenticity } = 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)');
+    // 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}`);
+    }
     const tarballPath = join(stagingDir, 'release.tgz');
-    log('Downloading latest release tarball...');
-    execFileSync('curl', ['-sL', '-f', '-H', 'Accept: application/vnd.github+json', tarballUrl, '-o', tarballPath],
+    log(`Downloading release v${rel.version}...`);
+    execFileSync('curl', ['-sL', '-f', '-H', 'Accept: application/vnd.github+json', rel.tarballUrl, '-o', tarballPath],
       { timeout: 60000, stdio: ['ignore', 'pipe', 'inherit'] });
     log('Extracting...');
     execFileSync('tar', ['xzf', tarballPath, '-C', stagingDir, '--strip-components=1'],
       { timeout: 30000, stdio: ['ignore', 'pipe', 'inherit'] });
+    // 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...');
+    const authentic = await verifyReleaseAuthenticity(stagingDir, rel.assets);
+    if (!authentic.ok) throw new Error(`release signature check failed (${authentic.action})`);
     const tarballInstaller = join(stagingDir, 'install.mjs');
-    if (!existsSync(tarballInstaller)) {
-      fail('Tarball missing install.mjs — repair aborted');
-      process.exit(1);
-    }
-    log('Re-running install from freshly-downloaded sources...');
+    if (!existsSync(tarballInstaller)) throw new Error('verified tarball missing install.mjs');
+    log('Re-running install from the verified release sources...');
     execFileSync(process.execPath, [tarballInstaller, 'install'],
       { stdio: 'inherit', timeout: 300000 });
-    ok('Repair complete — broken install resynced from latest release');
+    ok(`Repair complete — resynced from verified release v${rel.version}`);
   } catch (e) {
     fail(`Repair failed: ${e.message}`);
     console.log('');
-    console.log('  Manual fallback — run this in any shell:');
+    console.log('  Automatic repair fails closed rather than run unverified code.');
+    console.log('  Manual fallback — run this in any shell (you are choosing to trust it):');
     console.log('');
     console.log('  T=$(mktemp -d) && curl -sL https://api.github.com/repos/sdsrss/claude-mem-lite/tarball | tar xz -C "$T" --strip-components=1 && node "$T/install.mjs" install');
     console.log('');

package/lib/atomic-write.mjs

@@ -8,7 +8,7 @@
 // This writes to a pid-unique temp then renames (atomic on POSIX), and can drop
 // a one-time ".bak" so a logic bug in the caller's merge is recoverable.
 
-import { writeFileSync, renameSync, existsSync, copyFileSync, mkdirSync } from 'node:fs';
+import { writeFileSync, renameSync, existsSync, copyFileSync, mkdirSync, lstatSync, realpathSync } from 'node:fs';
 import { dirname } from 'node:path';
 
 /**
@@ -22,17 +22,28 @@ import { dirname } from 'node:path';
  *   preserves the last-known-good rather than being overwritten each run.
  */
 export function atomicWriteFileSync(filePath, data, { backup = false } = {}) {
-  const dir = dirname(filePath);
+  // Write THROUGH a symlink to its real target. renameSync onto a symlink NAME replaces the
+  // link with a regular file, silently orphaning a dotfiles-managed (chezmoi/stow/yadm)
+  // config: ~/.claude/settings.json (and ~/.claude.json) get severed from the dotfiles
+  // repo, so future dotfiles edits stop applying and .bak captures the wrong content.
+  // Resolve first, then put the temp in the TARGET's dir so the rename stays same-device
+  // (atomic, no EXDEV). A broken/absent symlink falls through to a direct write.
+  let target = filePath;
+  try {
+    if (lstatSync(filePath).isSymbolicLink()) target = realpathSync(filePath);
+  } catch { /* not a symlink, or missing — write filePath directly */ }
+
+  const dir = dirname(target);
   if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
 
-  if (backup && existsSync(filePath) && !existsSync(filePath + '.bak')) {
-    try { copyFileSync(filePath, filePath + '.bak'); } catch { /* best-effort backup */ }
+  if (backup && existsSync(target) && !existsSync(target + '.bak')) {
+    try { copyFileSync(target, target + '.bak'); } catch { /* best-effort backup */ }
   }
 
   // pid-unique temp: a fixed ".tmp" name lets two concurrent installs clobber
-  // each other's temp mid-write. Same-dir temp keeps the rename atomic (no
-  // cross-device move).
-  const tmp = `${filePath}.tmp-${process.pid}`;
+  // each other's temp mid-write. Same-dir-as-target temp keeps the rename atomic (no
+  // cross-device move) even when the target lives in a dotfiles repo on another mount.
+  const tmp = `${target}.tmp-${process.pid}`;
   writeFileSync(tmp, data);
-  renameSync(tmp, filePath);
+  renameSync(tmp, target);
 }

package/lib/citation-tracker.mjs

@@ -525,7 +525,7 @@ export function computeCitationAdoption(db, project) {
  * decide cited vs uncited and mutate importance/streak/cited_count per spec.
  *
  * - cited: importance += 1 (cap 3), cited_count += 1, streak = 0.
- * - uncited: streak += 1; if it reaches 3, importance -= 1 (floor 0), streak = 0.
+ * - uncited: streak += 1; if it reaches 3, importance -= 1 (floor 1, IMPORTANCE_FLOOR), streak = 0.
  * - per-(session, obs) idempotent via last_decided_session_id; re-running for
  *   the same session is a no-op (Stop hook may fire more than once).
  * - cross-project IDs are silently ignored by the WHERE clause.
@@ -568,7 +568,10 @@ export function applyCitationDecay(db, project, injectedIds, citedIds, sessionId
   const suppressDemotion = adoption.seen >= ADOPTION_MIN_SEEN && adoption.rate < adoptionThreshold;
 
   const selectStmt = db.prepare(
-    'SELECT id, importance, uncited_streak, last_decided_session_id FROM observations WHERE id = ? AND project = ?'
+    // superseded_at IS NULL: mirror computeCitationAdoption + the 4 injection SELECTs so a
+    // row superseded mid-session (injected live, then auto-dedup supersedes it before this
+    // decay resolves) is not decayed/streaked/mutated — defense-in-depth parity.
+    'SELECT id, importance, uncited_streak, last_decided_session_id FROM observations WHERE id = ? AND project = ? AND superseded_at IS NULL'
   );
   // decay_seen_count (v34) bumps on every resolution branch — gives
   // citation-stats a denominator that's same-source as cited_count, so the

package/lib/deferred-work.mjs

@@ -119,7 +119,9 @@ export function resolveDeferredIds(db, project, tokens) {
         throw new Error(`D#${id} belongs to project "${row.project}", not "${project}"`);
       }
       if (row.status !== 'open') {
-        throw new Error(`D#${id} status is "${row.status}", cannot close (only 'open' items)`);
+        // Verb-neutral: resolveDeferredIds is shared by close (save --closes-deferred)
+        // AND drop (mem_defer_drop), so "cannot close" mis-described the drop path.
+        throw new Error(`D#${id} status is "${row.status}" — only 'open' items can be closed or dropped`);
       }
     } else {
       throw new Error(`invalid token type ${typeof t} — expected D#N or integer ordinal`);

package/lib/doctor-benchmark.mjs

@@ -110,7 +110,12 @@ export function runBenchmark(db, { prompts = [], project = 'mem', skipHookLatenc
    * Returns true iff the simulator would produce a non-empty injection.
    */
   const runInjection = (promptText) => {
-    if (!promptText || promptText.trim().length < 15) return false;
+    // Mirror the real hook's min-length gate (hook-memory.mjs searchRelevantMemories):
+    // 5-char floor for non-CJK, 2 for CJK. The old flat 15 was 3x stricter and dropped
+    // every 5-14-char prompt (and all 2-14-char CJK) the live hook processes, so the
+    // simulated injection_rate systematically under-counted "how often memory fires".
+    const cjk = /[一-鿿㐀-䶿]/.test(promptText || '');
+    if (!promptText || promptText.length < (cjk ? 2 : 5)) return false;
     const q = sanitizeFtsQuery(promptText);
     if (!q) return false;
     try {

package/lib/maintain-core.mjs

@@ -145,6 +145,12 @@ export function cleanupBroken(db, { projectFilter, baseParams, opCap = OP_CAP })
     SELECT id FROM observations
     WHERE COALESCE(compressed_into, 0) = 0
       AND (title IS NULL OR title = '') AND (narrative IS NULL OR narrative = '')
+      -- A lesson-bearing row is NOT "broken" — it still carries the distilled value,
+      -- so empty title+narrative isn't grounds to hard-delete it (a degenerate
+      -- cluster-merge can write merged_title='' onto a row that kept a synthesized
+      -- lesson). Parity with the "lessons never auto-GC" guards in
+      -- decayAndMarkIdle / selectCompressionCandidates / findSmartCompressCandidates.
+      AND (lesson_learned IS NULL OR lesson_learned = '' OR lesson_learned = 'none')
       ${projectFilter} LIMIT ${opCap}
   `).all(...baseParams).map(r => r.id);
   if (!doomed.length) return 0;
@@ -329,6 +335,12 @@ export function purgeStalePreview(db, { projectFilter, baseParams }, retainCutof
 
 /** Delete pending-purge observations older than the retain cutoff. Returns rows deleted. */
 export function purgeStale(db, { projectFilter, baseParams, opCap = OP_CAP }, retainCutoff) {
+  // No lesson guard HERE by design: this hard-DELETE only touches rows already
+  // marked COMPRESSED_PENDING_PURGE, and every writer of that sentinel is itself
+  // lesson-guarded (decayAndMarkIdle above + search-scoring.runIdleCleanup), so a
+  // lesson row can never reach here. INVARIANT: any NEW code that sets
+  // compressed_into = COMPRESSED_PENDING_PURGE MUST carry the "lessons never auto-GC"
+  // guard, or it re-opens the path that hard-deletes lessons through this DELETE.
   const doomed = db.prepare(`
     SELECT id FROM observations
     WHERE compressed_into = ${COMPRESSED_PENDING_PURGE} AND created_at_epoch < ?

package/lib/task-imperative.mjs

@@ -3,6 +3,8 @@
 // measurement that gates Phase 2): ONE tested source of truth so the measured
 // framing and the shipped framing cannot drift. Hot-path-shared → regex/string
 // only, NO heavy imports (lesson #8447), mirroring lib/lesson-idents.mjs.
+// format-utils.mjs is a zero-import pure-string module, so it respects that constraint.
+import { neutralizeContextDelimiters } from '../format-utils.mjs';
 //
 // Delivers a high-value lesson at the task-prompt position as an imperative,
 // task-bound constraint: attribution kept (honest + #NN cite-traceable), the
@@ -11,7 +13,7 @@
 // Spec: docs/superpowers/specs/2026-06-29-task-imperative-memory-injection-design.md
 
 export function formatTaskImperative(lesson, id) {
-  const body = String(lesson || '').trim().replace(/\.$/, '');
+  const body = neutralizeContextDelimiters(String(lesson || '').trim().replace(/\.$/, ''));
   if (!body) return '';
   const tag = (id === undefined || id === null || id === '') ? '' : ` (#${id})`;
   return `Memory — a past lesson applies to THIS task. You must: ${body}.${tag}`;
@@ -27,7 +29,7 @@ export function formatTaskImperative(lesson, id) {
 // / "reference, not an instruction" / appended-below-the-task / no adversarial
 // tokens) are the measured difference between adopt and refuse — do not drift them.
 export function formatSubagentContext(lesson, id) {
-  const body = String(lesson || '').trim().replace(/\.$/, '');
+  const body = neutralizeContextDelimiters(String(lesson || '').trim().replace(/\.$/, ''));
   if (!body) return '';
   const tag = (id === undefined || id === null || id === '') ? '' : `#${id} — `;
   return [

package/mem-cli.mjs

@@ -605,21 +605,17 @@ function cmdTimeline(db, args) {
   // (nlp.mjs string ops on a boolean). No sensible default for a search anchor — reject
   // cleanly (#8470). (`--project` bare is absorbed by resolveProject's non-string guard.)
   if (rejectBareStringFlags(flags, ['query'])) return;
-  // parseInt('-5') === -5 is truthy, so `|| 5` doesn't rescue negative input.
-  // Match cmdSearch's warn-then-default pattern for consistency across CLI flags.
-  const parseWindow = (label, raw) => {
-    if (raw === undefined) return 5;
-    const n = parseInt(raw, 10);
-    // isNumericToken first: "2abc"→2 / "1e2"→1 are non-negative integers the bare check
-    // accepted silently; reject garbage tokens like the negative path already does.
-    if (!isNumericToken(raw) || !Number.isInteger(n) || n < 0) {
-      process.stderr.write(`[mem] Invalid --${label} "${raw}" (must be a non-negative integer); using default 5\n`);
-      return 5;
-    }
-    return n;
-  };
-  const before = parseWindow('before', flags.before);
-  const after = parseWindow('after', flags.after);
+  // Route --before/--after through the shared bounded parser, range [0,50] (mirrors MCP
+  // mem_timeline's before/after .min(0).max(50)). NOTE this is parseIntFlag's reject-to-default
+  // convention, NOT a clamp: an out-of-range value (e.g. `--before 100`) warns to stderr and
+  // falls back to the default 5 — same as recent/search/recall, so the behavior is consistent
+  // across the CLI (the user sees the valid range and can retry). The point is the UPPER bound:
+  // the old hand-rolled validator had none, so `--before 999999999` flowed straight into
+  // `LIMIT before+after+1` / the window fetch as a raw SQL LIMIT (whole-table dump) — the
+  // #8802 uncapped-LIMIT footgun. min:0 keeps a 0 window legal; parseIntFlag preserves the
+  // warn-then-default garbage handling (float truncation + "2abc"/"1e2" rejection).
+  const before = parseIntFlag(flags.before, { name: '--before', defaultValue: 5, min: 0, max: 50 });
+  const after = parseIntFlag(flags.after, { name: '--after', defaultValue: 5, min: 0, max: 50 });
   const project = flags.project ? resolveProject(db, flags.project) : null;
   const jsonOutput = flags.json === true || flags.json === 'true';
 
@@ -1621,7 +1617,17 @@ function cmdExport(db, args) {
     process.stderr.write(`[mem] Note: --from "${flags.from}" is after --to "${flags.to}"; this range is empty\n`);
   }
 
-  const limit = parseIntFlag(flags.limit, { name: '--limit', defaultValue: 200, max: 1000 });
+  // Backup default: with no --limit, export the COMPLETE matching set. `export` is
+  // the documented backup half of backup/restore (README; cmdRestore header), yet its
+  // old default capped at 200 (hard max 1000) and the "capped" warning went only to
+  // stderr — so a bare `export > backup.json` on a >200-row store silently wrote a
+  // truncated backup that lost rows on restore, and `--limit 5000` was REJECTED back
+  // to 200 (can't back up >1000 at all). Now: omit --limit → LIMIT -1 (SQLite = no
+  // limit); pass --limit N → honor any positive N (a backup may exceed 1000).
+  const limitGiven = flags.limit !== undefined && flags.limit !== null && flags.limit !== '';
+  const limit = limitGiven
+    ? parseIntFlag(flags.limit, { name: '--limit', defaultValue: 200 })
+    : -1;
   const format = flags.format || 'json';
   if (!['json', 'jsonl'].includes(format)) {
     fail(`[mem] Invalid format "${format}". Use: json or jsonl`);
@@ -1662,8 +1668,8 @@ function cmdExport(db, args) {
     out(JSON.stringify(rows, null, 2));
   }
 
-  if (rows.length >= limit) {
-    process.stderr.write(`[mem] Note: Results capped at ${limit}. Use --from/--to or --limit to export more.\n`);
+  if (limitGiven && rows.length >= limit) {
+    process.stderr.write(`[mem] Note: Results capped at ${limit}. Raise --limit or narrow --from/--to to export more.\n`);
   }
 }
 
@@ -1785,8 +1791,13 @@ function cmdCompress(db, args) {
     // isNumericToken (not bare parseInt) so "1e5"→1 and "30x"→30 are rejected rather than
     // silently mis-parsed into a far-too-broad cutoff — parity with recent/search/maintain.
     const parsed = Number(flags['age-days']);
-    if (!isNumericToken(flags['age-days']) || !Number.isInteger(parsed) || parsed < 1) {
-      fail(`[mem] Invalid --age-days "${flags['age-days']}". Must be a positive integer.`);
+    // [30,365] floor/ceil = parity with mem_compress (tool-schemas memCompressSchema
+    // .min(30).max(365)). The CLI previously accepted any positive int, so `--age-days 1`
+    // compressed day-old rows while the MCP description claimed the CLI "rejects <30 anyway"
+    // — a false parity claim (the candidate gate is the real data guard, but the age floor
+    // should match the tool the description promises equivalence with).
+    if (!isNumericToken(flags['age-days']) || !Number.isInteger(parsed) || parsed < 30 || parsed > 365) {
+      fail(`[mem] Invalid --age-days "${flags['age-days']}". Must be an integer between 30 and 365 (parity with mem_compress).`);
       return;
     }
     ageDays = parsed;
@@ -2575,15 +2586,17 @@ Commands:
     --narrative T       New narrative
     --concepts T        Space-separated concept tags
 
-  export                Export observations as JSON/JSONL
-  restore <file>        Restore observations from an export file (JSON/JSONL); --dry-run to preview
+  export                Export observations as JSON/JSONL (complete backup by default)
     --project P         Filter by project
     --type T            Filter by type
     --format F          json (default) or jsonl
     --from DATE         Start date
     --to DATE           End date
     --include-compressed  Include compressed observations
-    --limit N           Max results (default 200, max 1000)
+    --limit N           Cap output at N rows (default: export ALL matching rows)
+  restore <file>        Restore observations from an export file (JSON/JSONL)
+    --project P         Override the restored project for every row
+    --dry-run           Preview what would be restored without writing
 
   compress              Compress old low-value observations
     --execute           Execute compression (preview by default)
@@ -2876,6 +2889,18 @@ async function cmdEnrich(argv) {
 }
 
 async function cmdOptimize(db, args) {
+  // cmdOptimize parses flags positionally (args.indexOf('--task') + args[idx+1])
+  // instead of the shared parseArgs, so the GNU `--flag=value` form silently
+  // vanished: indexOf found no bare `--flag`, dropping the value with zero signal.
+  // On the mutating --run path this was a real footgun — `optimize --run
+  // --task=smart-compress --project=p --max=5` ran ALL tasks across ALL projects at
+  // the default budget (tasks/project undefined → run-everything). Normalize
+  // `--flag=value` into `--flag value` up front so both forms parse identically;
+  // the `--execute=` special-case below already anticipated this for one flag.
+  args = args.flatMap(a => {
+    const m = /^(--[a-z][a-z-]*)=([\s\S]*)$/.exec(a);
+    return m ? [m[1], m[2]] : [a];
+  });
   const run = args.includes('--run');
   const runAll = args.includes('--run-all');
   // Sibling-command flag footgun: optimize executes with --run (compress uses
@@ -3045,11 +3070,15 @@ export async function run(argv) {
   const JSON_SUPPORTED_CMDS = new Set([
     'search', 'context', 'recent', 'recall', 'timeline', 'stats', 'browse', 'export', 'citation-stats',
   ]);
-  // `doctor --benchmark` already emits JSON on its own — don't print the misleading
-  // "doctor outputs text" note for that subpath. Without --benchmark, doctor is text
-  // and the note is still useful.
-  const doctorBenchmark = cmd === 'doctor' && cmdArgs.includes('--benchmark');
-  if (cmdArgs.includes('--json') && !JSON_SUPPORTED_CMDS.has(cmd) && !doctorBenchmark) {
+  // Suppress the note on subpaths that DO emit JSON, so it never FALSELY tells a script
+  // "outputs text" while writing valid JSON to stdout — a false note is worse than a
+  // missing one (it makes the consumer skip a parse that would have succeeded). doctor
+  // emits JSON for --benchmark / --metrics / --session-audit; activity's show/save emit
+  // JSON. Without those sub-flags, doctor is text and the note stays useful.
+  const jsonCapableSubpath =
+    (cmd === 'doctor' && (cmdArgs.includes('--benchmark') || cmdArgs.includes('--metrics') || cmdArgs.includes('--session-audit'))) ||
+    cmd === 'activity';
+  if (cmdArgs.includes('--json') && !JSON_SUPPORTED_CMDS.has(cmd) && !jsonCapableSubpath) {
     process.stderr.write(`[mem] Note: --json is supported only on: ${[...JSON_SUPPORTED_CMDS].join(', ')}. "${cmd}" outputs text.\n`);
   }
 

package/nlp.mjs

@@ -151,10 +151,14 @@ export function extractCjkLikePatterns(query) {
 /**
  * Post-FTS precision filter for CJK queries.
  *
- * Background: FTS5 unicode61 tokenizer splits every CJK character into its
- * own token. An application-layer bigram query like "我是" then reduces to
- * (我 AND 是) at match time — matching any document that happens to contain
- * both chars anywhere, which is extremely permissive in Chinese prose.
+ * Background: this build's FTS5 unicode61 tokenizer indexes an entire CJK run
+ * as ONE token (it does NOT split each CJK character). CJK text is made
+ * searchable by the write path, which stores the content plus its space-
+ * separated overlapping bigrams; a query is likewise reduced to bigrams. An
+ * application-layer bigram query therefore matches via those stored bigrams,
+ * and after the AND→OR fallback (relaxFtsQueryToOr) any document sharing even a
+ * single query bigram becomes a hit — extremely permissive in Chinese prose,
+ * where common bigrams recur across unrelated topics.
  *
  * Precision check: given the raw query and a candidate result's full text,
  * require that at least `threshold` fraction of the query's CJK bigrams
@@ -276,6 +280,15 @@ export function sanitizeFtsQuery(query) {
       t && !/^-+$/.test(t) && !FTS5_KEYWORDS.has(t.toUpperCase()) && !/^NEAR(\/\d*)?$/i.test(t)
       // Skip single ASCII-letter tokens — too noisy for FTS5 (CJK single chars handled separately below)
       && !(t.length === 1 && /^[a-zA-Z]$/.test(t))
+      // Drop tokens with NO index-able character — emoji 💥, symbols ★☆✦, pure
+      // punctuation. unicode61 strips those at index time, so ftsToken would phrase-quote
+      // such a token ("💥") into a REQUIRED AND term that can never match → strict FTS
+      // returns 0 (and a lone-emoji query has no OR recovery). Gate on any Unicode LETTER
+      // or NUMBER (\p{L}/\p{N}), NOT an ASCII+Han allowlist: unicode61 indexes every
+      // script's letters (Cyrillic / Greek / kana / Hangul / Thai / accented Latin …), so
+      // an allowlist silently killed search for all non-Latin/non-Han scripts (round-5
+      // review catch). Letters are kept; only true symbols/emoji/punctuation are dropped.
+      && /[\p{L}\p{N}]/u.test(t)
     );
   // Filter stop words (but keep all if filtering would empty the query)
   const filtered = tokens.filter(t => !FTS_STOP_WORDS.has(t.toLowerCase()));
@@ -303,6 +316,25 @@ export function sanitizeFtsQuery(query) {
         }
         continue;
       }
+      // No dictionary word matched. For a PURE-CJK run, pushing the whole
+      // unsegmented token creates a required AND term that matches neither the
+      // stored full-run token nor its overlapping bigrams: the write path stores
+      // content + space-separated bigrams, so a run like "同义词扩展" is indexed
+      // only as the longer whole-run token AND as 同义/义词/词扩/扩展 — never as
+      // "同义词扩展" itself. The strict AND is thus unsatisfiable (strict FTS = 0);
+      // only relaxFtsQueryToOr in the callers salvaged recall. Emit the non-noise
+      // bigrams the index actually holds instead. Mixed-script tokens (latin+CJK,
+      // e.g. "xyzAbc不存在") stay whole — the latin portion is a literal anchor and
+      // bigramming the CJK suffix over-recalls (mirrors the bigram guard below).
+      if (!/[A-Za-z0-9]/.test(t)) {
+        const fallbackBigrams = cjkBigrams(t)
+          .split(' ')
+          .filter(bg => bg && !isCjkNoiseBigram(bg));
+        if (fallbackBigrams.length > 0) {
+          expandedTokens.push(...fallbackBigrams);
+          continue;
+        }
+      }
     }
     expandedTokens.push(t);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "3.35.2",
+  "version": "3.37.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",
@@ -102,7 +102,6 @@
     "registry.mjs",
     "registry-retriever.mjs",
     "registry-recommend.mjs",
-    "registry-indexer.mjs",
     "registry-scanner.mjs",
     "registry-github.mjs",
     "registry-importer.mjs",