claude-mem-lite 3.52.0 → 3.54.0

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
   "plugins": [
     {
       "name": "claude-mem-lite",
-      "version": "3.52.0",
+      "version": "3.54.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.52.0",
+  "version": "3.54.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/README.md

@@ -684,41 +684,43 @@ and `benchmark/longmemeval-rerank.mjs` (rerank).
 
 | Retriever (zero embeddings) | @1 | @5 | @10 |
 |---|---|---|---|
-| Lexical hybrid — FTS5 + TF-IDF + RRF | 76.8% | 90.6% | 95.2% |
-| + one top-20 LLM rerank pass | **92.8%** | **96.8%** | **97.4%** |
-
-*n = 500 questions; 99.8% JSON parse-rate at concurrency 3.* The rerank pass
-hands the top 20 lexical candidates to a single Haiku call (~1.4 s/query) that
-reorders them. It is **never worse than the lexical baseline by construction** —
-any LLM or parse failure falls back to the original candidate order.
+| Lexical hybrid — FTS5 + TF-IDF + RRF | **83.4%** | **95.2%** | **96.0%** |
+| + one top-20 LLM rerank pass † | 92.8% | 96.8% | 97.4% |
+
+*n = 500 questions.* The lexical row was re-measured 2026-07-18: the v3.39–v3.45
+alias/synonym-pipeline work lifted it from the previously published 76.8/90.6/95.2
+on the **same harness and dataset** (both unchanged since that run — the gain is
+engine-side, not metric drift). † The rerank row is the 2026-06 measurement taken
+against the *older* lexical baseline; with lexical now at 95.2 @5 its remaining
+headroom is ~1.6pt and a re-measurement is pending. The rerank pass hands the top
+20 lexical candidates to a single Haiku call (~1.4 s/query) that reorders them; it
+is **never worse than the lexical baseline by construction** — any LLM or parse
+failure falls back to the original candidate order.
 
 **Stricter metric, for the record.** The rows above are `recall_any@k` — does *any*
 gold session reach the top *k* — the metric agentmemory and MemPalace publish, so the
 comparison is like-for-like. Under the stricter **standard recall@k** (`|gold ∩ top-k| /
 |gold|`, the *fraction* of all gold sessions retrieved), the lexical stack scores
-@1 = 46.9% / @5 = 84.4% / @10 = 91.9%. The whole gap is the 65% of questions with
+@1 = 52.9% / @5 = 87.8% / @10 = 91.0%. The whole gap is the 65% of questions with
 multiple gold sessions — any-hit needs one, fractional needs them all, and @1 is capped
 at 1/|gold| there; single-gold question types score identically under both.
 `benchmark/longmemeval.mjs` reports both columns (the rerank row's fractional is not yet
 measured).
 
-**On embeddings, honestly.** With no LLM in the loop, both a dense-embedding
-baseline (MemPalace, ~96.6% @5) and a BM25 + vector + graph hybrid (agentmemory,
-95.2% @5) out-recall our zero-embedding lexical stack (90.6% @5) at the same
-retrieval stage — dense and graph signal genuinely help raw recall, and most of
-our remaining gap is paraphrase (single-session-preference is our lowest category
-at 63%). The rerank row's point is that a *single cheap LLM call closes it*:
-reordering the top-20 lexical candidates reaches 96.8% @5 — matching the dense raw
-number and edging the hybrid's retrieval score — because the lexical candidate set
-is already rich enough (recall@20 = 97.8%) that ranking, not recall, is the
-bottleneck. An embedding-plus-rerank stack still leads when both sides spend an LLM
-call; the takeaway is that claude-mem-lite reaches embedding-competitive precision
-with **no vector model, no knowledge graph, no Python, and no external service**.
-
-Per-category @5 (lexical → +rerank): knowledge-update 98.7 → 100.0 ·
-single-session-user 91.4 → 98.6 · temporal-reasoning 89.5 → 97.7 · multi-session
-95.5 → 97.7 · single-session-assistant 83.9 → 94.6 · single-session-preference
-63.3 → 80.0. Every category improves; none regress.
+**On embeddings, honestly.** With no LLM in the loop, our zero-embedding lexical
+stack now **ties** the BM25 + vector + graph hybrid (agentmemory, 95.2% @5) at the
+same retrieval stage; a dense-embedding baseline (MemPalace, ~96.6% @5) still leads
+by ~1.4pt. The remaining gap concentrates in paraphrase (single-session-preference
+is our lowest category at 80.0% @5). The rerank row's point stands: a *single cheap
+LLM call* reorders the top-20 lexical candidates because the candidate set is
+already rich enough that ranking, not recall, is the bottleneck. An
+embedding-plus-rerank stack still leads when both sides spend an LLM call; the
+takeaway is that claude-mem-lite reaches embedding-competitive recall with **no
+vector model, no knowledge graph, no Python, and no external service**.
+
+Per-category any@5, lexical (2026-07-18 run): knowledge-update 100.0 ·
+single-session-user 100.0 · multi-session 94.7 · single-session-assistant 94.6 ·
+temporal-reasoning 94.0 · single-session-preference 80.0.
 
 ## Development
 

package/hook.mjs

@@ -27,6 +27,7 @@ import {
   extractErrorKeywords, extractFilePaths, isRelatedToEpisode,
   makeEntryDesc, scrubSecrets, stripPrivate, EDIT_TOOLS, debugCatch, debugLog,
   COMPRESSED_AUTO, OBS_BM25, notLowSignalTitleClause, formatErrorRecallHints,
+  MAX_HOOK_STDIN_BYTES,
 } from './utils.mjs';
 import {
   readEpisodeRaw, episodeFile,
@@ -64,7 +65,7 @@ import { searchRelevantMemories, formatMemoryLine, selectImperativeLesson } from
 import { searchInjectableEvents, renderInjectableEvent } from './lib/events-injection.mjs';
 import { formatTaskImperative } from './lib/task-imperative.mjs';
 import { recordSkillAdoption, gcOldShadowShards } from './registry-recommend.mjs';
-import { gcOldMetricShards } from './lib/metrics.mjs';
+import { gcOldMetricShards, recordMetric } from './lib/metrics.mjs';
 import { detectMemOverride } from './lib/mem-override.mjs';
 import { buildAndSaveHandoff, detectContinuationIntent, renderHandoffInjection, pickHandoffToInject, extractUnfinishedSummary } from './hook-handoff.mjs';
 import { checkForUpdate, getCachedUpdateBanner, isUpdateCheckDue } from './hook-update.mjs';
@@ -433,6 +434,10 @@ function triggerErrorRecall(db, toolInput, response) {
 
     const out = formatErrorRecallHints(rows);
     if (out) {
+      // G13: this surface feeds the citation denominator but had zero metering —
+      // the G8 gate change (isError→isHardError) could not be volume-verified
+      // from metrics. Counter only; no latency (query is bundled in the hook).
+      recordMetric(join(RUNTIME_DIR, '..'), { event: 'error_recall', returned: rows.length });
       // MED-3 (full audit 2026-07-16): emit via the JSON envelope (trailing '\n'),
       // NOT raw stdout. A raw multi-line write corrupts a co-emitted episode-flush
       // receipt (both write to PostToolUse stdout in the same call → `<text>{json}`)
@@ -668,7 +673,13 @@ async function handleStop() {
               } else {
                 const citedMain = extractCitationsFromTranscript(transcriptPath, { mainOnly: true });
                 for (const id of citeBackIds) citedMain.add(id);
-                const r = applyCitationDecay(db, project, injected, citedMain, sessionId);
+                // D#60: the idempotency key must be the CC session UUID, NOT the
+                // project-scoped memory sessionId — concurrent same-project CC
+                // sessions share the latter, so the second session's decay pass
+                // read "already decided" and silently undercounted decay_seen /
+                // streaks / adoption denominators. Fallback keeps legacy
+                // stdin-less invocations on the old key.
+                const r = applyCitationDecay(db, project, injected, citedMain, ccSessionId || sessionId);
                 debugLog('DEBUG', 'handleStop', `citation-decay: touched=${r.touched} promoted=${r.promoted} demoted=${r.demoted}`);
                 // R1: persist this session's invocation→cite funnel row. touched =
                 // obs resolved this run (denominator), promoted = obs cited this run
@@ -1621,8 +1632,19 @@ async function handleEnrichSave(rawId) {
   if (!db) return;
   try {
     const { executeSaveEnrich } = await import('./lib/save-enrich.mjs');
-    await executeSaveEnrich(db, id);
+    const result = await executeSaveEnrich(db, id);
+    // G13: the worker's outcome was previously discarded — "spawned but did it
+    // work" was invisible (32% alias coverage with 3 indistinguishable failure
+    // causes). reason 'filled-concurrently' = txn ran but a concurrent optimize/
+    // update had already filled every empty field.
+    recordMetric(join(RUNTIME_DIR, '..'), {
+      event: 'enrich_save',
+      id,
+      enriched: result.enriched,
+      reason: result.reason ?? (result.enriched ? 'enriched' : 'filled-concurrently'),
+    });
   } catch (e) {
+    recordMetric(join(RUNTIME_DIR, '..'), { event: 'enrich_save', id, enriched: false, reason: 'worker-error' });
     debugCatch(e, 'enrich-save');
   } finally {
     try { db.close(); } catch {}
@@ -1666,7 +1688,7 @@ function handleAutoCompress() {
 // ─── Utilities ──────────────────────────────────────────────────────────────
 
 function readStdin() {
-  const MAX_STDIN = 256 * 1024; // 256KB — large tool responses are truncated
+  const MAX_STDIN = MAX_HOOK_STDIN_BYTES; // large tool responses are truncated (shared tier, utils.mjs)
   return new Promise((resolve, reject) => {
     let data = '';
     const timeout = setTimeout(() => { debugLog('WARN', 'readStdin', 'stdin timeout after 3s — event dropped'); process.stdin.destroy(); reject(new Error('timeout')); }, 3000);

package/lib/citation-tracker.mjs

@@ -599,9 +599,35 @@ export function applyCitationDecay(db, project, injectedIds, citedIds, sessionId
   const empty = { promoted: 0, demoted: 0, touched: 0 };
   if (process.env.MEM_DISABLE_CITATION_DECAY === '1') return empty;
   if (!db || !project || !sessionId) return empty;
-  const injected = injectedIds instanceof Set ? injectedIds : new Set(injectedIds || []);
+  let injected = injectedIds instanceof Set ? injectedIds : new Set(injectedIds || []);
   if (injected.size === 0) return empty;
-  const cited = citedIds instanceof Set ? citedIds : new Set(citedIds || []);
+  let cited = citedIds instanceof Set ? citedIds : new Set(citedIds || []);
+
+  // D#61: a lesson injected live and then superseded mid-session (auto-dedup /
+  // supersedes= save) leaves its citation crediting NOBODY — selectStmt below
+  // excludes superseded rows by design (defense-in-depth parity), so the keeper
+  // that now carries the lesson goes uncredited. Redirect such ids to their
+  // NUMERIC superseded_by keeper (one hop; superseded_by is polymorphic — the
+  // typeof guard mirrors timeline-core). Copies, not mutation: callers own the
+  // input sets.
+  const redirectStmt = db.prepare(
+    'SELECT superseded_by FROM observations WHERE id = ? AND project = ? AND superseded_at IS NOT NULL'
+  );
+  const redirectSet = (set) => {
+    const out = new Set();
+    for (const id of set) {
+      const r = redirectStmt.get(id, project);
+      if (r && typeof r.superseded_by === 'number' && Number.isInteger(r.superseded_by)
+          && r.superseded_by > 0 && r.superseded_by !== id) {
+        out.add(r.superseded_by);
+      } else {
+        out.add(id);
+      }
+    }
+    return out;
+  };
+  injected = redirectSet(injected);
+  cited = redirectSet(cited);
 
   // Adoption gate (snapshot taken before any mutation this run). Suppress only
   // demotion; promotion always proceeds. Threshold overridable via env.

package/lib/deferred-work.mjs

@@ -61,7 +61,9 @@ export function listOpenWithOrdinal(db, project, limit = 10) {
 // ─── G11: list age + stale refresh hint (roadmap 2026-07-18) ─────────────────
 
 const DAY_MS = 86_400_000;
-export const DEFER_STALE_DAYS = 30;
+// Internal const (was exported at v3.51.0 birth with zero external importers —
+// knip-baseline discipline: un-export rather than grow the unused-exports list).
+const DEFER_STALE_DAYS = 30;
 
 /**
  * Render one `defer list` row (shared by CLI cmdDeferList and MCP

package/lib/persist-reminder.mjs

@@ -48,6 +48,14 @@ const PERSIST_TOOL_NAMES = new Set([
   'mcp__plugin_claude-mem-lite_mem-lite__mem_defer',
 ]);
 const PERSIST_CLI_RE = /(?:cli\.mjs|claude-mem-lite)['"]?\s+(?:save\b|defer\s+add\b)/;
+// G18: Skill-path persistence. /lesson /memory /bug land observations (or memdir
+// files) just as deliberately as mem_save — without these, a session that
+// finalized AND persisted via a skill still got the reminder (false positive).
+// Skill values may be plugin-qualified ('claude-mem-lite:lesson') or bare.
+const PERSIST_SKILL_RE = /(?:^|:)(?:lesson|memory|bug)$/;
+// G18: memory-dir writes (~/.claude/projects/<slug>/memory/*.md, incl. MEMORY.md
+// index updates) are the durable-layer persistence path for decisions.
+const MEMDIR_WRITE_RE = /[\\/]\.claude[\\/]projects[\\/][^\\/]+[\\/]memory[\\/][^\\/]+\.md$/;
 
 /**
  * Count deliberate persistence calls (mem_save / mem_defer tool_use, CLI
@@ -68,7 +76,10 @@ export function countDeliberatePersistence(transcriptPath) {
     for (const block of content) {
       if (block.type !== 'tool_use') continue;
       if (PERSIST_TOOL_NAMES.has(block.name)) { count++; continue; }
-      if (block.name === 'Bash' && PERSIST_CLI_RE.test(block.input?.command || '')) count++;
+      if (block.name === 'Bash' && PERSIST_CLI_RE.test(block.input?.command || '')) { count++; continue; }
+      if (block.name === 'Skill' && PERSIST_SKILL_RE.test(block.input?.skill || '')) { count++; continue; }
+      if ((block.name === 'Write' || block.name === 'Edit')
+        && MEMDIR_WRITE_RE.test(block.input?.file_path || '')) count++;
     }
   }
   return count;

package/lib/search-core.mjs

@@ -266,9 +266,11 @@ export function searchEventsFts(db, { ftsQuery, project = null, projectBoost = n
 //   ratio ≥ 0.5 → -0.75  comparable to the best: above neutral, below the leaders
 //   ratio ≥ 0.1 → -0.5   the MED-5 neutral mid
 //   ratio < 0.1 → -0.25  grazing match: sink it
-// score === 0 rows (the prompts CJK LIKE fallback — zero confidence) are excluded
-// from normalization entirely and keep their 0, sorting last in the ascending
-// merge (audit L3: the old clamp promoted a lone 0-score row to the neutral mid).
+// score === 0 rows are excluded from normalization entirely and keep their 0,
+// sorting last in the ascending merge (audit L3: the old clamp promoted a lone
+// 0-score row to the neutral mid). Two producers emit score 0 — the prompts CJK
+// LIKE fallback AND the obs type-list fallback below (both zero-confidence, both
+// gated so they never coexist with scored rows of their own source).
 const SINGLE_MATCH_BANDS = [
   [1.0, -1.05],
   [0.5, -0.75],
@@ -289,8 +291,10 @@ export function normalizeCrossSourceScores(results, sourceKey) {
   const globalMaxAbs = scored.length ? Math.max(...scored.map((r) => Math.abs(r.score))) : 0;
   for (const src of ['obs', 'session', 'prompt', 'event']) {
     // score === 0 stays out: for multi-row sources 0/maxAbs would be 0 anyway, and a
-    // lone 0-score row must not be banded upward (it only occurs as the prompts LIKE
-    // fallback, which never coexists with real prompt FTS hits).
+    // lone 0-score row must not be banded upward. Two 0-score producers exist (G19
+    // comment fix — "only the prompts LIKE fallback" was incomplete): the prompts CJK
+    // LIKE fallback (never coexists with real prompt FTS hits) and the obs type-list
+    // fallback (gated on results.length === 0, so it never coexists with ANY scored row).
     const srcResults = results.filter((r) => r[sourceKey] === src && r.score !== null && r.score !== undefined && r.score !== 0);
     if (srcResults.length === 0) continue;
     if (srcResults.length === 1) {

package/mem-cli.mjs

@@ -50,7 +50,7 @@ import { buildSearchFtsQuery, parseDateBounds, parseDuration, coreRunSearchPipel
 import { AUTO_MERGE_THRESHOLD } from './lib/dedup-constants.mjs';
 import { countRecentHookErrors } from './lib/hook-telemetry.mjs';
 import { computeCitationFunnelTrend } from './lib/citation-tracker.mjs';
-import { aggregateMetrics } from './lib/metrics.mjs';
+import { aggregateMetrics, readMetrics } from './lib/metrics.mjs';
 import {
   insertDeferred, listOpenWithOrdinal, dropDeferred,
   resolveDeferredIds, closeDeferredItems,
@@ -1254,6 +1254,18 @@ async function cmdStats(db, args) {
   const rrN = featAgg.reread_warn?.count ?? 0;
   const metricsOn = process.env.CLAUDE_MEM_METRICS === '1';
   out(`  Feature injections (7d): 📄 file-intel ${fiN} · 🔁 reread-warn ${rrN}${(!metricsOn && fiN + rrN === 0) ? '  (set CLAUDE_MEM_METRICS=1 to record)' : ''}`);
+  // G13: surface the recall/enrich metering so "did the worker succeed" is
+  // readable from stats, not just raw jsonl. enrich-save shows ok/total; the
+  // per-reason split (llm-null vs txn-failed …) stays a jq query on the jsonl.
+  const prN = featAgg.pretool_recall?.count ?? 0;
+  const erN = featAgg.error_recall?.count ?? 0;
+  let esOk = 0, esN = 0;
+  for (const r of readMetrics(DB_DIR, 7)) {
+    if (r.event === 'enrich_save') { esN++; if (r.enriched) esOk++; }
+  }
+  if (prN + erN + esN > 0 || metricsOn) {
+    out(`  Recall metering (7d): 🧠 pretool ${prN} · ⛑ error-recall ${erN} · ✚ enrich-save ${esOk}/${esN} ok`);
+  }
   if (noiseRatio > 0.6 || lowSignalRatio > 0.3) out('  ⚠️ High noise ratio — consider running mem maintain / compress');
   out('');
   // Tier counts only live (uncompressed, non-superseded) observations — surface the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "3.52.0",
+  "version": "3.54.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",

package/scripts/pre-agent-inject.js

@@ -24,7 +24,8 @@ function readStdin() {
       data += c;
       // cap: agent prompts can be large. destroy() so the loop can drain and exit on
       // its own (see the no-forced-exit note at the bottom) rather than streaming to
-      // the 1.5s timeout.
+      // the 1.5s timeout. 262144 = MAX_HOOK_STDIN_BYTES (utils.mjs) repeated as a
+      // literal ON PURPOSE: the default-off fast path above must stay import-free.
       if (data.length > 262144) { clearTimeout(timer); try { process.stdin.destroy(); } catch { /* */ } resolve(data.slice(0, 262144)); }
     });
     process.stdin.on('end', () => { clearTimeout(timer); resolve(data); });

package/scripts/pre-tool-recall.js

@@ -512,6 +512,19 @@ try {
     // unreadable files. When present (first Read of a sizable file this session),
     // it leads the injection, above any lessons.
     const hasLessons = allRows.length > 0;
+    // G13: obs/event lesson recall is the largest injected_n contributor
+    // (session max observed: 105) yet had no firing counter — file_intel/
+    // reread_warn were metered while the actual #NN injections were invisible.
+    // Source split lets the D#78 per-surface attribution read obs vs events.
+    if (hasLessons) {
+      recordMetric(DATA_DIR, {
+        event: 'pretool_recall',
+        injected: allRows.length,
+        obs: allRows.filter(r => r.src === 'obs').length,
+        evt: allRows.filter(r => r.src === 'evt').length,
+        mode: isRead ? 'read' : 'edit',
+      });
+    }
     const showFraming = hasLessons || Boolean(fileIntelLine)
       || (!isRead && process.env.CLAUDE_MEM_PRETOOL_NUDGE === '1');
     if (showFraming) {

package/scripts/user-prompt-search.js

@@ -4,7 +4,7 @@
 // Lightweight: only imports schema.mjs and utils.mjs, no MCP SDK
 
 import { ensureDb, DB_DIR, REGISTRY_DB_PATH } from '../schema.mjs';
-import { sanitizeFtsQuery, relaxFtsQueryToOr, truncate, typeIcon, inferProject, OBS_BM25, TYPE_DECAY_CASE, TYPE_QUALITY_CASE, notLowSignalTitleClause, noisePenaltyClause, stripPrivate, neutralizeContextDelimiters } from '../utils.mjs';
+import { sanitizeFtsQuery, relaxFtsQueryToOr, truncate, typeIcon, inferProject, OBS_BM25, TYPE_DECAY_CASE, TYPE_QUALITY_CASE, notLowSignalTitleClause, noisePenaltyClause, stripPrivate, neutralizeContextDelimiters, MAX_UPS_PROMPT_BYTES } from '../utils.mjs';
 import { citeFactorClause } from '../scoring-sql.mjs';
 import { cjkPrecisionOk } from '../nlp.mjs';
 import { writeFileSync, readFileSync, existsSync, renameSync } from 'fs';
@@ -446,11 +446,12 @@ function readStdin() {
     process.stdin.setEncoding('utf8');
     process.stdin.on('data', chunk => {
       data += chunk;
-      // Cap at 64KB — user prompts shouldn't be huge
-      if (data.length > 65536) {
+      // Cap the prompt (#9494 huge-prompt guard) — deliberately tighter than the
+      // 256KB full-payload tier; both tiers live in utils.mjs (G19).
+      if (data.length > MAX_UPS_PROMPT_BYTES) {
         process.stdin.destroy();
         clearTimeout(timeout);
-        resolve(data.slice(0, 65536));
+        resolve(data.slice(0, MAX_UPS_PROMPT_BYTES));
       }
     });
     process.stdin.on('end', () => { clearTimeout(timeout); resolve(data); });

package/utils.mjs

@@ -93,6 +93,14 @@ export function clampImportance(val) {
 // Tools that produce file edits (used for significance detection, feedback, importance)
 export const EDIT_TOOLS = new Set(['Edit', 'Write', 'NotebookEdit']);
 
+// Stdin caps for the hook entry points (G19). Two DELIBERATE tiers, not drift:
+// full hook payloads carry tool_response bodies (256KB), while the UserPromptSubmit
+// search surface caps the prompt itself at 64KB (#9494 huge-prompt guard — search
+// relevance gains nothing past that). scripts/pre-agent-inject.js repeats the
+// 256KB literal by design: its default-off path must stay import-free.
+export const MAX_HOOK_STDIN_BYTES = 256 * 1024;
+export const MAX_UPS_PROMPT_BYTES = 64 * 1024;
+
 // Low-signal degraded title patterns — shared by hook-llm.mjs (dedup + importance cap) and hook-handoff.mjs (decision filter)
 // Two top-level alternatives:
 //   1. ^(prefix1|prefix2|...) — title starts with one of the hook-llm fallback prefixes