claude-mem-lite 2.63.0 → 2.65.0

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
   "plugins": [
     {
       "name": "claude-mem-lite",
-      "version": "2.63.0",
+      "version": "2.65.0",
       "source": "./",
       "description": "Lightweight persistent memory system for Claude Code — FTS5 search, episode batching, error-triggered recall"
     }

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "2.63.0",
+  "version": "2.65.0",
   "description": "Lightweight persistent memory system for Claude Code — FTS5 search, episode batching, error-triggered recall",
   "author": {
     "name": "sdsrss"

package/cli/fts-check.mjs

@@ -8,7 +8,7 @@ export function cmdFtsCheck(db, args) {
   const { positional } = parseArgs(args);
   const action = positional[0];
   if (!action || !['check', 'rebuild'].includes(action)) {
-    fail('[mem] Usage: mem fts-check <check|rebuild>');
+    fail('[mem] Usage: claude-mem-lite fts-check <check|rebuild>');
     return;
   }
 

package/install.mjs

@@ -1295,14 +1295,29 @@ async function doctor() {
     dwarn('Database: not found (will be created)');
   }
 
-  // Check for stale processes
+  // Check for stale processes — extends beyond legacy chroma/worker to
+  // catch MCP launchers / servers from cached old plugin versions. Auto-update
+  // bumps installed_plugins.json but cannot kill the MCP process spawned for
+  // an active session, so v2.60.0/v2.61.0 launchers commonly outlive their
+  // version (recurrent pattern, see #2580 for the gsd analogue). Filtering
+  // strategy: legacy chroma/worker = always stale; cache-path launchers = only
+  // when their version segment ≠ current package.json version; dev-install
+  // paths (no version segment) are never flagged.
   try {
-    const procs = execFileSync('pgrep', ['-af', 'chroma|claude-mem.*worker'], { encoding: 'utf8', timeout: 5000, stdio: 'pipe' }).trim();
-    // Filter out the pgrep process itself (matches its own pattern)
-    const real = procs.split('\n').filter(l => !l.includes('pgrep'));
-    if (real.length > 0) {
-      warn('Old processes running:\n    ' + real.join('\n    '));
+    const procs = execFileSync('pgrep', ['-af', 'chroma|claude-mem-lite.*(scripts/launch|server)\\.mjs|claude-mem.*worker'], { encoding: 'utf8', timeout: 5000, stdio: 'pipe' }).trim();
+    const lines = procs.split('\n').filter(l => l && !l.includes('pgrep'));
+    let currentVersion = '';
+    try { currentVersion = JSON.parse(readFileSync(join(PROJECT_DIR, 'package.json'), 'utf8')).version; } catch { /* fall through with empty version */ }
+    const stale = lines.filter(l => {
+      if (/chroma|claude-mem.*worker/.test(l)) return true;
+      const m = l.match(/claude-mem-lite\/(\d+\.\d+\.\d+)\/(scripts\/launch|server)\.mjs/);
+      return m && currentVersion && m[1] !== currentVersion;
+    });
+    if (stale.length > 0) {
+      warn(`Old processes running${currentVersion ? ` (current: v${currentVersion})` : ''}:\n    ` + stale.join('\n    '));
       issues++;
+    } else {
+      ok('No stale processes');
     }
   } catch {
     ok('No stale processes');
@@ -1333,19 +1348,31 @@ async function doctor() {
   }
 
   // Dev drift: in dev-mode installs, all SOURCE_FILES entries should be
-  // symlinks. A plain file means an earlier install (or manual cp) copied it,
-  // so edits in the repo won't propagate to INSTALL_DIR — hook runtime and
-  // test runtime silently diverge.
+  // symlinks. A plain file means an earlier install (or manual cp) copied it
+  // (edits in the repo won't propagate). A missing entry (neither symlink nor
+  // plain) means an earlier install never wrote the file — same divergence
+  // class. Per #8043: "is this file present ≠ is this install consistent" —
+  // missing is tracked separately by checkDevDrift but the caller MUST surface
+  // it to honour #8268's "gate the all-green string on every counter" rule.
   try {
     const { checkDevDrift } = await import('./lib/doctor-drift.mjs');
     const r = checkDevDrift(INSTALL_DIR, SOURCE_FILES);
-    if (r.drift) {
-      const names = r.details.join(', ');
-      const suffix = r.plainCount > r.details.length ? ` +${r.plainCount - r.details.length} more` : '';
-      warn(`Dev drift: ${r.plainCount} non-symlink file(s) in dev install: ${names}${suffix} (re-run: node ${join(PROJECT_DIR, 'install.mjs')} install --dev)`);
+    if (r.drift || (r.devMode && r.missingCount > 0)) {
+      const parts = [];
+      if (r.plainCount > 0) {
+        const names = r.plainFiles.slice(0, 5).join(', ');
+        const suffix = r.plainCount > 5 ? ` +${r.plainCount - 5} more` : '';
+        parts.push(`${r.plainCount} non-symlink: ${names}${suffix}`);
+      }
+      if (r.missingCount > 0) {
+        const names = r.missingFiles.join(', ');
+        const suffix = r.missingCount > r.missingFiles.length ? ` +${r.missingCount - r.missingFiles.length} more` : '';
+        parts.push(`${r.missingCount} missing: ${names}${suffix}`);
+      }
+      warn(`Dev drift: ${parts.join('; ')} (re-run: node ${join(PROJECT_DIR, 'install.mjs')} install --dev)`);
       issues++;
     } else if (r.devMode) {
-      ok(`Dev drift: clean (${r.symlinkCount} symlinks, 0 plain)`);
+      ok(`Dev drift: clean (${r.symlinkCount} symlinks, 0 plain, 0 missing)`);
     }
     // Prod (all plain) install: no message — dev-drift is a dev-only concern.
   } catch (e) {

package/lib/doctor-drift.mjs

@@ -41,6 +41,7 @@ export function checkDevDrift(installDir, sourceFiles) {
     plainCount: plainFiles.length,
     plainFiles,
     missingCount: missing.length,
+    missingFiles: missing.slice(0, 5),
     details: plainFiles.slice(0, 5),
   };
 }

package/lib/save-observation.mjs

@@ -1,5 +1,5 @@
 // Shared "save one observation" pipeline — used by both mem-cli.mjs::cmdSave
-// (CLI `mem save`) and server.mjs::mem_save (MCP tool).
+// (CLI `claude-mem-lite save`) and server.mjs::mem_save (MCP tool).
 //
 // Pre-extraction (v2.60.0) the same dedup → scrub → minhash → CJK-bigram →
 // transactional INSERT block lived inline in both call sites (~110 lines × 2,

package/mem-cli.mjs

@@ -34,12 +34,17 @@ function cmdSearch(db, args) {
   const { positional, flags } = parseArgs(args);
   const query = positional.join(' ');
   if (!query) {
-    fail('[mem] Usage: mem search <query> [--type TYPE] [--source SOURCE] [--limit N] [--project P] [--from DATE] [--to DATE] [--importance N] [--branch B] [--offset N] [--sort relevance|time|importance] [--include-noise]');
+    fail('[mem] Usage: claude-mem-lite search <query> [--type TYPE] [--source SOURCE] [--limit N] [--project P] [--from DATE] [--to DATE] [--importance N] [--branch B] [--offset N] [--sort relevance|time|importance] [--include-noise]');
     return;
   }
 
   const rawLimit = flags.limit !== undefined ? parseInt(flags.limit, 10) : NaN;
-  const limit = Number.isInteger(rawLimit) ? Math.max(1, rawLimit) : 20;
+  // Distinguish missing/non-integer (use default) from non-positive (silently clamping to 1
+  // produced confusing "Found 1 of 44 result" output for --limit 0/-N — warn instead).
+  if (flags.limit !== undefined && (!Number.isInteger(rawLimit) || rawLimit < 1)) {
+    process.stderr.write(`[mem] Invalid --limit "${flags.limit}" (must be a positive integer); using default 20\n`);
+  }
+  const limit = Number.isInteger(rawLimit) && rawLimit >= 1 ? rawLimit : 20;
   const type = flags.type || null;
   const validObsTypes = new Set(['decision', 'bugfix', 'feature', 'refactor', 'discovery', 'change']);
   if (type && !validObsTypes.has(type)) {
@@ -53,13 +58,22 @@ function cmdSearch(db, args) {
   if (dateTo && flags.to && /^\d{4}-\d{2}-\d{2}$/.test(flags.to)) dateTo += 86400000 - 1;
   if (flags.from && isNaN(dateFrom)) { fail(`[mem] Invalid --from date: "${flags.from}". Use YYYY-MM-DD or ISO 8601.`); return; }
   if (flags.to && isNaN(dateTo)) { fail(`[mem] Invalid --to date: "${flags.to}". Use YYYY-MM-DD or ISO 8601.`); return; }
+  // Inverted range silently returns 0 rows; warn so users see the cause, don't error
+  // (a deliberate "search for nothing in this window" is not malformed input).
+  if (dateFrom !== null && dateTo !== null && dateFrom > dateTo) {
+    process.stderr.write(`[mem] Note: --from "${flags.from}" is after --to "${flags.to}"; this range is empty\n`);
+  }
   const minImportance = flags.importance !== undefined ? parseInt(flags.importance, 10) : null;
   if (minImportance !== null && (isNaN(minImportance) || minImportance < 1 || minImportance > 3)) {
     fail(`[mem] Invalid --importance "${flags.importance}". Must be 1, 2, or 3.`);
     return;
   }
   const branch = flags.branch || null;
-  const offset = Math.max(0, parseInt(flags.offset, 10) || 0);
+  const rawOffset = flags.offset !== undefined ? parseInt(flags.offset, 10) : NaN;
+  if (flags.offset !== undefined && (!Number.isInteger(rawOffset) || rawOffset < 0)) {
+    process.stderr.write(`[mem] Invalid --offset "${flags.offset}" (must be a non-negative integer); using 0\n`);
+  }
+  const offset = Number.isInteger(rawOffset) && rawOffset >= 0 ? rawOffset : 0;
   const tier = flags.tier || null;
   if (tier && !['working', 'active', 'archive'].includes(tier)) {
     fail(`[mem] Invalid --tier "${tier}". Use: working, active, archive`);
@@ -338,7 +352,9 @@ function cmdSearch(db, args) {
   }
 
   const countLabel = total > paged.length ? `${paged.length} of ${total}` : `${paged.length}`;
-  out(`[mem] Found ${countLabel} result${paged.length !== 1 ? 's' : ''} for "${query}"${fallbackHint}:${hasMixed ? ' (# observation, S# session, P# prompt)' : ''}`);
+  // Pluralize on total — "Found 1 of 44 result" reads wrong; the population (44) drives
+  // grammatical number, not the page slice (1).
+  out(`[mem] Found ${countLabel} result${total !== 1 ? 's' : ''} for "${query}"${fallbackHint}:${hasMixed ? ' (# observation, S# session, P# prompt)' : ''}`);
   for (const r of paged) {
     const timeStr = showTime && r.created_at_epoch ? ` (${relativeTime(r.created_at_epoch)})` : '';
     if (r._source === 'session') {
@@ -400,13 +416,16 @@ function cmdRecall(db, args) {
   const { positional, flags } = parseArgs(args);
   const file = positional.join(' ');
   if (!file) {
-    fail('[mem] Usage: mem recall <file> [--limit N] [--include-noise]');
+    fail('[mem] Usage: claude-mem-lite recall <file> [--limit N] [--include-noise]');
     return;
   }
 
   const filename = basename(file);
   const rawLimit = flags.limit !== undefined ? parseInt(flags.limit, 10) : NaN;
-  const limit = Number.isInteger(rawLimit) ? Math.max(1, rawLimit) : 10;
+  if (flags.limit !== undefined && (!Number.isInteger(rawLimit) || rawLimit < 1)) {
+    process.stderr.write(`[mem] Invalid --limit "${flags.limit}" (must be a positive integer); using default 10\n`);
+  }
+  const limit = Number.isInteger(rawLimit) && rawLimit >= 1 ? rawLimit : 10;
   const includeNoise = flags['include-noise'] === true || flags['include-noise'] === 'true';
 
   // Search via observation_files junction table for indexed filename lookups
@@ -530,7 +549,7 @@ function cmdGet(db, args) {
   const { positional, flags } = parseArgs(args);
   const idStr = positional.join(',');
   if (!idStr) {
-    fail('[mem] Usage: mem get <id1,id2,...> [--source obs|session|prompt] [--fields f1,f2,...]\n' +
+    fail('[mem] Usage: claude-mem-lite get <id1,id2,...> [--source obs|session|prompt] [--fields f1,f2,...]\n' +
          '        IDs accept prefix from search output: #123 (obs), P#123 (prompt), S#123 (session).');
     return;
   }
@@ -602,8 +621,19 @@ function cmdGet(db, args) {
 
 function cmdTimeline(db, args) {
   const { positional, flags } = parseArgs(args);
-  const before = parseInt(flags.before, 10) || 5;
-  const after = parseInt(flags.after, 10) || 5;
+  // 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);
+    if (!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);
   const project = flags.project ? resolveProject(db, flags.project) : null;
 
   // Parse --anchor, accepting P#/S#/# prefix so callers can paste search-result IDs verbatim.
@@ -785,7 +815,7 @@ function cmdSave(db, args) {
   const { positional, flags } = parseArgs(args);
   const text = positional.join(' ');
   if (!text) {
-    fail('[mem] Usage: mem save "<text>" [--type T] [--title T] [--importance N] [--project P] [--files f1,f2] [--lesson T]');
+    fail('[mem] Usage: claude-mem-lite save "<text>" [--type T] [--title T] [--importance N] [--project P] [--files f1,f2] [--lesson T]');
     return;
   }
 
@@ -967,6 +997,9 @@ async function cmdStats(db, args) {
   const compressedCount = db.prepare(
     `SELECT COUNT(*) as c FROM observations WHERE compressed_into IS NOT NULL ${projectFilter}`
   ).get(...baseParams);
+  const supersededOnlyCount = db.prepare(
+    `SELECT COUNT(*) as c FROM observations WHERE superseded_at IS NOT NULL AND compressed_into IS NULL ${projectFilter}`
+  ).get(...baseParams);
 
   // Tier distribution (aligned with MCP mem_stats)
   const tierCtx = { now, currentProject: project || inferProject(), currentSessionId: '' };
@@ -1005,7 +1038,11 @@ async function cmdStats(db, args) {
   out(`  Compressed: ${compressedCount.c}`);
   if (noiseRatio > 0.6) out('  ⚠️ High noise ratio — consider running mem compress');
   out('');
-  out('Tier distribution:');
+  // Tier counts only live (uncompressed, non-superseded) observations — surface the
+  // full decomposition so live + compressed + superseded = Total adds up cleanly.
+  const tierTotal = (tierMap.working ?? 0) + (tierMap.active ?? 0) + (tierMap.archive ?? 0);
+  const supersededLabel = supersededOnlyCount.c > 0 ? ` + ${supersededOnlyCount.c} superseded` : '';
+  out(`Tier distribution (live ${tierTotal}, excludes ${compressedCount.c} compressed${supersededLabel}):`);
   out(`  🔴 Working: ${tierMap.working ?? 0} | 🟡 Active: ${tierMap.active ?? 0} | 🔵 Archive: ${tierMap.archive ?? 0}`);
 }
 
@@ -1137,7 +1174,7 @@ function cmdDelete(db, args) {
   const { positional, flags } = parseArgs(args);
   const idStr = positional.join(',');
   if (!idStr) {
-    fail('[mem] Usage: mem delete <id1,id2,...> [--confirm]');
+    fail('[mem] Usage: claude-mem-lite delete <id1,id2,...> [--confirm]');
     return;
   }
 
@@ -1147,7 +1184,7 @@ function cmdDelete(db, args) {
   const nonObs = tokens.filter(t => /^[PpSs]#?\d+$/.test(t));
   if (nonObs.length > 0) {
     fail(`[mem] delete only works on observations. Rejected: ${nonObs.join(', ')}. ` +
-         `Prompts and sessions are append-only — inspect with \`mem get P#N --source prompt\` / \`--source session\`.`);
+         `Prompts and sessions are append-only — inspect with \`claude-mem-lite get P#N --source prompt\` / \`--source session\`.`);
     return;
   }
   const ids = tokens.map(t => {
@@ -1215,7 +1252,7 @@ function cmdUpdate(db, args) {
   const parsed = raw ? parseIdToken(raw) : null;
   const id = parsed && parsed.source === null ? parsed.id : parseInt(raw, 10);
   if (!id || isNaN(id)) {
-    fail('[mem] Usage: mem update <id> [--title T] [--type T] [--importance N] [--lesson T] [--narrative T] [--concepts T]');
+    fail('[mem] Usage: claude-mem-lite update <id> [--title T] [--type T] [--importance N] [--lesson T] [--narrative T] [--concepts T]');
     return;
   }
 
@@ -1297,16 +1334,21 @@ function cmdExport(db, args) {
   const project = flags.project ? resolveProject(db, flags.project) : null;
   if (project) { wheres.push('project = ?'); params.push(project); }
   if (flags.type) { wheres.push('type = ?'); params.push(flags.type); }
+  let exportFromEpoch = null;
+  let exportToEpoch = null;
   if (flags.from) {
-    const epoch = new Date(flags.from).getTime();
-    if (isNaN(epoch)) { fail(`[mem] Invalid --from date: "${flags.from}". Use YYYY-MM-DD or ISO 8601.`); return; }
-    wheres.push('created_at_epoch >= ?'); params.push(epoch);
+    exportFromEpoch = new Date(flags.from).getTime();
+    if (isNaN(exportFromEpoch)) { fail(`[mem] Invalid --from date: "${flags.from}". Use YYYY-MM-DD or ISO 8601.`); return; }
+    wheres.push('created_at_epoch >= ?'); params.push(exportFromEpoch);
   }
   if (flags.to) {
-    let epoch = new Date(flags.to).getTime();
-    if (isNaN(epoch)) { fail(`[mem] Invalid --to date: "${flags.to}". Use YYYY-MM-DD or ISO 8601.`); return; }
-    if (/^\d{4}-\d{2}-\d{2}$/.test(flags.to)) epoch += 86400000 - 1;
-    wheres.push('created_at_epoch <= ?'); params.push(epoch);
+    exportToEpoch = new Date(flags.to).getTime();
+    if (isNaN(exportToEpoch)) { fail(`[mem] Invalid --to date: "${flags.to}". Use YYYY-MM-DD or ISO 8601.`); return; }
+    if (/^\d{4}-\d{2}-\d{2}$/.test(flags.to)) exportToEpoch += 86400000 - 1;
+    wheres.push('created_at_epoch <= ?'); params.push(exportToEpoch);
+  }
+  if (exportFromEpoch !== null && exportToEpoch !== null && exportFromEpoch > exportToEpoch) {
+    process.stderr.write(`[mem] Note: --from "${flags.from}" is after --to "${flags.to}"; this range is empty\n`);
   }
 
   const rawLimit = flags.limit !== undefined ? parseInt(flags.limit, 10) : NaN;
@@ -1442,7 +1484,7 @@ function cmdMaintain(db, args) {
   const { positional, flags } = parseArgs(args);
   const action = positional[0];
   if (!action || !['scan', 'execute'].includes(action)) {
-    fail('[mem] Usage: mem maintain <scan|execute> [--ops cleanup,decay,boost,dedup,purge_stale,rebuild_vectors] [--project P] [--retain-days N] [--merge-ids keepId:removeId,...]');
+    fail("[mem] Usage: claude-mem-lite maintain <scan|execute> [--ops cleanup,decay,boost,dedup,purge_stale,rebuild_vectors] [--project P] [--retain-days N] [--merge-ids keepId:removeId,...] — 'scan' previews, 'execute' applies.");
     return;
   }
 
@@ -1722,7 +1764,7 @@ function cmdRegistry(_memDb, args) {
   const { positional, flags } = parseArgs(args);
   const action = positional[0];
   if (!action || !['list', 'stats', 'search', 'import', 'remove', 'reindex'].includes(action)) {
-    fail('[mem] Usage: mem registry <list|stats|search|import|remove|reindex> [--type skill|agent] [--query Q] [--name N] [--resource-type T]');
+    fail('[mem] Usage: claude-mem-lite registry <list|stats|search|import|remove|reindex> [--type skill|agent] [--query Q] [--name N] [--resource-type T]');
     return;
   }
 
@@ -1738,7 +1780,7 @@ function cmdRegistry(_memDb, args) {
   try {
     if (action === 'search') {
       const query = flags.query || positional.slice(1).join(' ');
-      if (!query) { fail('[mem] Usage: mem registry search <query> [--type skill|agent] [--category C] [--quality Q]'); return; }
+      if (!query) { fail('[mem] Usage: claude-mem-lite registry search <query> [--type skill|agent] [--category C] [--quality Q]'); return; }
       let results = searchResources(rdb, query, {
         type: flags.type || undefined,
         limit: (flags.category || flags.quality) ? 20 : 10,
@@ -1828,7 +1870,7 @@ function cmdRegistry(_memDb, args) {
     if (action === 'import') {
       const name = flags.name;
       const resourceType = flags['resource-type'];
-      if (!name || !resourceType) { fail('[mem] Usage: mem registry import --name N --resource-type skill|agent [--invocation-name I] [--capability-summary S]'); return; }
+      if (!name || !resourceType) { fail('[mem] Usage: claude-mem-lite registry import --name N --resource-type skill|agent [--invocation-name I] [--capability-summary S]'); return; }
       const fields = { name, type: resourceType, status: 'active', source: flags.source || 'user' };
       for (const f of ['repo-url', 'local-path', 'invocation-name', 'intent-tags', 'domain-tags', 'trigger-patterns', 'capability-summary', 'keywords', 'tech-stack', 'use-cases']) {
         const camel = f.replace(/-([a-z])/g, (_, c) => '_' + c);
@@ -1849,7 +1891,7 @@ function cmdRegistry(_memDb, args) {
     if (action === 'remove') {
       const name = flags.name;
       const resourceType = flags['resource-type'];
-      if (!name || !resourceType) { fail('[mem] Usage: mem registry remove --name N --resource-type skill|agent'); return; }
+      if (!name || !resourceType) { fail('[mem] Usage: claude-mem-lite registry remove --name N --resource-type skill|agent'); return; }
       const result = rdb.prepare('DELETE FROM resources WHERE type = ? AND name = ?').run(resourceType, name);
       out(result.changes > 0 ? `[mem] Removed: ${resourceType}:${name}` : '[mem] Not found.');
       return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "2.63.0",
+  "version": "2.65.0",
   "description": "Lightweight persistent memory system for Claude Code",
   "type": "module",
   "packageManager": "npm@10.9.2",

package/server.mjs

@@ -1005,6 +1005,9 @@ server.registerTool(
     const compressedCount = db.prepare(`
       SELECT COUNT(*) as c FROM observations WHERE compressed_into IS NOT NULL ${projectFilter}
     `).get(...baseParams);
+    const supersededOnlyCount = db.prepare(`
+      SELECT COUNT(*) as c FROM observations WHERE superseded_at IS NOT NULL AND compressed_into IS NULL ${projectFilter}
+    `).get(...baseParams);
 
     // Tier distribution
     const tierCtx = { now: Date.now(), currentProject: args.project || inferProject(), currentSessionId: '' };
@@ -1038,7 +1041,9 @@ server.registerTool(
       `  Compressed: ${compressedCount.c}`,
       ...(noiseRatio > 0.6 ? ['  ⚠️ High noise ratio — consider running mem_compress'] : []),
       '',
-      'Tier distribution:',
+      // Tier counts only live (uncompressed, non-superseded) observations — surface
+      // the full decomposition so live + compressed + superseded = Total adds up cleanly.
+      `Tier distribution (live ${(tierMap.working ?? 0) + (tierMap.active ?? 0) + (tierMap.archive ?? 0)}, excludes ${compressedCount.c} compressed${supersededOnlyCount.c > 0 ? ` + ${supersededOnlyCount.c} superseded` : ''}):`,
       `  🔴 Working: ${tierMap.working ?? 0} | 🟡 Active: ${tierMap.active ?? 0} | 🔵 Archive: ${tierMap.archive ?? 0}`,
     ];