claude-mem-lite 2.66.0 → 2.69.0

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
   "plugins": [
     {
       "name": "claude-mem-lite",
-      "version": "2.66.0",
+      "version": "2.69.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.66.0",
+  "version": "2.69.0",
   "description": "Lightweight persistent memory system for Claude Code — FTS5 search, episode batching, error-triggered recall",
   "author": {
     "name": "sdsrss"

package/cli/activity.mjs

@@ -109,5 +109,52 @@ export async function cmdActivity(db, args) {
     return;
   }
 
+  if (sub === 'delete') {
+    // Mirrors cmdDelete (mem-cli.mjs:1316): preview by default, --confirm
+    // executes. Per Tier 3b in tasks/v2.66-carry-forward.md the events table
+    // accumulates corrupted titles from old hook-llm fallback bugs (#8158).
+    // This command lets users prune them by ID without dropping to raw SQL.
+    const idStr = positional.join(',').trim();
+    if (!idStr) {
+      fail('[mem] Usage: claude-mem-lite activity delete <id1,id2,...> [--confirm]');
+      return;
+    }
+    const ids = idStr.split(',')
+      .map(s => s.trim())
+      .filter(Boolean)
+      .map(s => parseInt(s, 10))
+      .filter(n => Number.isInteger(n) && n > 0);
+    if (ids.length === 0) {
+      fail('[mem] activity delete: no valid IDs provided (must be positive integers)');
+      return;
+    }
+
+    const placeholders = ids.map(() => '?').join(',');
+    const rows = db.prepare(`SELECT id, event_type, title FROM events WHERE id IN (${placeholders})`).all(...ids);
+    if (rows.length === 0) {
+      fail(`[mem] activity delete: no events found for ID(s) ${ids.join(', ')}`);
+      return;
+    }
+
+    const confirm = flags.confirm === true || flags.confirm === 'true';
+    if (!confirm) {
+      out(`[mem] Preview: ${rows.length} event(s) will be deleted:`);
+      for (const r of rows) {
+        const titleStr = (r.title || '').slice(0, 100);
+        out(`  #${r.id} [${r.event_type}] ${titleStr}`);
+      }
+      const missingIds = ids.filter(i => !rows.some(r => r.id === i));
+      if (missingIds.length > 0) {
+        out(`[mem] Note: ${missingIds.length} ID(s) not found and will be skipped: ${missingIds.join(', ')}`);
+      }
+      out('[mem] Run with --confirm to execute deletion.');
+      return;
+    }
+
+    const result = db.prepare(`DELETE FROM events WHERE id IN (${placeholders})`).run(...ids);
+    out(`[mem] Deleted ${result.changes} event(s).`);
+    return;
+  }
+
   fail(`[mem] Unknown activity subcommand: ${sub}`);
 }

package/hook-context.mjs

@@ -407,6 +407,30 @@ export function buildSessionContextLines(db, project, now = new Date(), currentC
     handoffLines.push('');
   }
 
+  // 5b. Deferred Work — project-level importance≥3 obs that survived prior
+  // session boundaries. Independent of the per-session handoff: even when the
+  // most recent /clear or /exit handoff has stale or meta-only `working_on`,
+  // genuine carry-forward decisions stay surfaced. Capped at 3 to keep the
+  // banner skim-able. Quiet-hooks does NOT suppress: the whole point is
+  // visibility for cross-session continuity.
+  const deferredObs = db.prepare(`
+    SELECT id, type, title FROM observations
+    WHERE project = ? AND COALESCE(compressed_into, 0) = 0
+      AND superseded_at IS NULL
+      AND COALESCE(importance, 1) >= 3
+      AND ${notLowSignalTitleClause('')}
+    ORDER BY created_at_epoch DESC LIMIT 3
+  `).all(project);
+
+  const deferredLines = [];
+  if (deferredObs.length > 0) {
+    deferredLines.push('### Deferred Work');
+    for (const o of deferredObs) {
+      deferredLines.push(`- ${typeIcon(o.type)} [${o.type}] ${truncate(o.title, 140)} (#${o.id})`);
+    }
+    deferredLines.push('');
+  }
+
   // 6. Recent observations table
   const obsLines = [];
   const obsToShow = observations.length >= 3 ? observations : fallbackObs;
@@ -422,7 +446,7 @@ export function buildSessionContextLines(db, project, now = new Date(), currentC
     }
   }
 
-  return [...summaryLines, ...handoffLines, ...obsLines].join('\n');
+  return [...summaryLines, ...handoffLines, ...deferredLines, ...obsLines].join('\n');
 }
 
 /**

package/hook-handoff.mjs

@@ -2,7 +2,7 @@
 // Extracted for testability — hook.mjs has module-level side effects
 
 import { basename } from 'path';
-import { truncate, extractMatchKeywords, tokenizeHandoff, isSpecificTerm, LOW_SIGNAL_TITLE, EDIT_TOOLS } from './utils.mjs';
+import { truncate, extractMatchKeywords, tokenizeHandoff, isSpecificTerm, LOW_SIGNAL_TITLE, EDIT_TOOLS, isMetaTriggerPrompt, notLowSignalTitleClause } from './utils.mjs';
 import {
   HANDOFF_EXPIRY_CLEAR, HANDOFF_EXPIRY_EXIT, HANDOFF_ANCHOR_MAX_AGE,
   HANDOFF_MATCH_THRESHOLD, CONTINUE_KEYWORDS,
@@ -39,14 +39,38 @@ export function buildAndSaveHandoff(db, sessionId, project, type, episodeSnapsho
   `).all(sessionId);
   if (prompts.length === 0) return;  // Empty session — nothing to hand off
 
+  // Filter prompts whose only content is workflow/control language ("继续",
+  // "提交代码", "/exit", etc.). Storing them verbatim into working_on creates
+  // self-referential handoffs ("Working On: 继续前面的工作") that point at the
+  // trigger instead of the subject. When ALL prompts are meta, fall back to
+  // the project's most recent importance≥3 non-low-signal observation as the
+  // carry-forward anchor — that's the closest durable signal of "what was
+  // being worked on at a higher level than this session".
+  const subjectPrompts = prompts.filter(p => !isMetaTriggerPrompt(p.prompt_text));
+  const sourcePrompts = subjectPrompts.length > 0 ? subjectPrompts : prompts;
+
   const seen = new Set();
-  const uniquePrompts = prompts.filter(p => {
+  const uniquePrompts = sourcePrompts.filter(p => {
     const t = truncate(p.prompt_text, 200);
     if (seen.has(t)) return false;
     seen.add(t);
     return true;
   });
-  const workingOn = uniquePrompts.map(p => truncate(p.prompt_text, 200)).join(' → ');
+  let workingOn = uniquePrompts.map(p => truncate(p.prompt_text, 200)).join(' → ');
+
+  if (subjectPrompts.length === 0) {
+    const fallback = db.prepare(`
+      SELECT title FROM observations
+      WHERE project = ? AND COALESCE(compressed_into, 0) = 0
+        AND superseded_at IS NULL
+        AND COALESCE(importance, 1) >= 3
+        AND ${notLowSignalTitleClause('')}
+      ORDER BY created_at_epoch DESC LIMIT 1
+    `).get(project);
+    if (fallback?.title) {
+      workingOn = `(carry-forward subject) ${truncate(fallback.title, 180)}`;
+    }
+  }
 
   // 2. Completed — from observations (include narrative for richer handoff)
   const completed = db.prepare(`

package/lib/cli-flags.mjs

@@ -0,0 +1,48 @@
+// CLI numeric-flag validation helper.
+//
+// Extends the audit pattern from #8277 (Number.isInteger + range check) with a
+// single reusable surface that also enforces upper bounds. The pre-existing
+// 5-line parseInt boilerplate was duplicated across cmdSearch / cmdRecall /
+// cmdBrowse / cmdTimeline / cmdExport — each maintainer drifted slightly,
+// and none capped --limit, so `claude-mem-lite search "x" --limit 99999999`
+// silently dumped the entire result set.
+//
+// Behavior contract:
+//   - Returns defaultValue when rawValue is undefined/null/empty.
+//   - On invalid input (non-integer, out of [min, max]), writes a single
+//     stderr warning and returns defaultValue. Does NOT throw — calling code
+//     keeps running with a sane fallback.
+//   - Returns rawValue (parsed) only when it's a finite integer in range.
+//
+// Caller responsibilities: pick min/max that make sense for the flag's
+// domain (e.g. --offset min=0; --limit max=1000; --importance min=1, max=3).
+
+const DEFAULT_STDERR_WRITE = msg => process.stderr.write(msg);
+
+/**
+ * Validate and parse a CLI numeric flag with optional bounds.
+ *
+ * @param {string|number|undefined|null} rawValue Flag value as captured by parseArgs (or undefined when absent).
+ * @param {object} opts
+ * @param {string} opts.name Flag name with leading dashes (e.g. "--limit") for the warning text.
+ * @param {number} opts.defaultValue Fallback when input is missing or invalid.
+ * @param {number} [opts.min=1] Inclusive lower bound.
+ * @param {number} [opts.max=Number.MAX_SAFE_INTEGER] Inclusive upper bound.
+ * @param {(msg: string) => void} [opts.warn] Test seam — defaults to process.stderr.write.
+ * @returns {number} Validated integer or defaultValue.
+ */
+export function parseIntFlag(rawValue, opts) {
+  const { name, defaultValue, min = 1, max = Number.MAX_SAFE_INTEGER, warn = DEFAULT_STDERR_WRITE } = opts;
+
+  if (rawValue === undefined || rawValue === null || rawValue === '') {
+    return defaultValue;
+  }
+
+  const parsed = parseInt(rawValue, 10);
+  if (!Number.isInteger(parsed) || parsed < min || parsed > max) {
+    const range = max === Number.MAX_SAFE_INTEGER ? `≥ ${min}` : `between ${min} and ${max}`;
+    warn(`[mem] Invalid ${name} "${rawValue}" (must be an integer ${range}); using default ${defaultValue}\n`);
+    return defaultValue;
+  }
+  return parsed;
+}

package/mem-cli.mjs

@@ -17,6 +17,7 @@ import { searchResources } from './registry-retriever.mjs';
 import { optimizePreview, optimizeRun } from './hook-optimize.mjs';
 import { buildSessionContextLines } from './hook-context.mjs';
 import { cmdAdopt, cmdUnadopt } from './adopt-cli.mjs';
+import { parseIntFlag } from './lib/cli-flags.mjs';
 import { auditMemdir, memdirPath } from './memdir.mjs';
 import { probeOtherSources as probeIdSources, bucketIdTokens } from './lib/id-routing.mjs';
 import { basename, join } from 'path';
@@ -38,13 +39,7 @@ function cmdSearch(db, args) {
     return;
   }
 
-  const rawLimit = flags.limit !== undefined ? parseInt(flags.limit, 10) : NaN;
-  // 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 limit = parseIntFlag(flags.limit, { name: '--limit', defaultValue: 20, max: 1000 });
   const type = flags.type || null;
   const validObsTypes = new Set(['decision', 'bugfix', 'feature', 'refactor', 'discovery', 'change']);
   if (type && !validObsTypes.has(type)) {
@@ -383,8 +378,14 @@ function cmdRecent(db, args) {
   if (rawArg !== undefined && !isValid) {
     process.stderr.write(`[mem] Invalid count "${rawArg}" (must be a positive integer); using default 10\n`);
   }
-  const limit = isValid ? rawLimit : 10;
+  // Positional [N] wins for backward-compat; --limit is sibling-parity alias
+  // (search/recall/browse/stats all accept --limit). Pre-2.69 `recent --limit N`
+  // was silently ignored — surprising users extrapolating from siblings.
+  const limit = isValid
+    ? rawLimit
+    : parseIntFlag(flags.limit, { name: '--limit', defaultValue: 10, max: 1000 });
   const project = flags.project ? resolveProject(db, flags.project) : inferProject();
+  const jsonOutput = flags.json === true || flags.json === 'true';
 
   const params = [];
   const wheres = ['COALESCE(compressed_into, 0) = 0', 'superseded_at IS NULL'];
@@ -392,13 +393,30 @@ function cmdRecent(db, args) {
   params.push(limit);
 
   const rows = db.prepare(`
-    SELECT id, type, title, subtitle, created_at_epoch, created_at
+    SELECT id, type, title, subtitle, importance, created_at_epoch, created_at
     FROM observations
     WHERE ${wheres.join(' AND ')}
     ORDER BY created_at_epoch DESC
     LIMIT ?
   `).all(...params);
 
+  if (jsonOutput) {
+    out(JSON.stringify({
+      project: project || null,
+      limit,
+      total: rows.length,
+      results: rows.map(r => ({
+        id: r.id,
+        type: r.type,
+        title: r.title || r.subtitle || null,
+        importance: r.importance ?? null,
+        created_at: r.created_at,
+        created_at_epoch: r.created_at_epoch,
+      })),
+    }));
+    return;
+  }
+
   if (rows.length === 0) {
     out(`[mem] No recent observations${project ? ` (${project})` : ''}`);
     return;
@@ -416,24 +434,22 @@ function cmdRecall(db, args) {
   const { positional, flags } = parseArgs(args);
   const file = positional.join(' ');
   if (!file) {
-    fail('[mem] Usage: claude-mem-lite recall <file> [--limit N] [--include-noise]');
+    fail('[mem] Usage: claude-mem-lite recall <file> [--limit N] [--include-noise] [--json]');
     return;
   }
 
   const filename = basename(file);
-  const rawLimit = flags.limit !== undefined ? parseInt(flags.limit, 10) : NaN;
-  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 limit = parseIntFlag(flags.limit, { name: '--limit', defaultValue: 10, max: 1000 });
   const includeNoise = flags['include-noise'] === true || flags['include-noise'] === 'true';
+  const jsonOutput = flags.json === true || flags.json === 'true';
 
   // Search via observation_files junction table for indexed filename lookups
   const escaped = filename.replace(/%/g, '\\%').replace(/_/g, '\\_');
   const likePattern = `%${escaped}`;
   const noiseClause = includeNoise ? '' : `AND ${notLowSignalTitleClause('o')}`;
   const rows = db.prepare(`
-    SELECT DISTINCT o.id, o.type, o.title, o.lesson_learned, o.created_at, o.project
+    SELECT DISTINCT o.id, o.type, o.title, o.lesson_learned, o.importance,
+                    o.created_at, o.created_at_epoch, o.project
     FROM observations o
     JOIN observation_files of2 ON of2.obs_id = o.id
     WHERE COALESCE(o.compressed_into, 0) = 0
@@ -443,18 +459,40 @@ function cmdRecall(db, args) {
     LIMIT ?
   `).all(filename, likePattern, limit);
 
+  if (rows.length > 0) {
+    // Update access_count for recalled observations (aligned with MCP mem_recall)
+    const recalledIds = rows.map(r => r.id);
+    const recallPh = recalledIds.map(() => '?').join(',');
+    try {
+      db.prepare(`UPDATE observations SET access_count = COALESCE(access_count, 0) + 1, last_accessed_at = ? WHERE id IN (${recallPh})`).run(Date.now(), ...recalledIds);
+    } catch { /* non-critical: FTS5 trigger may fail on corrupted index */ }
+  }
+
+  if (jsonOutput) {
+    out(JSON.stringify({
+      file: filename,
+      limit,
+      include_noise: includeNoise,
+      total: rows.length,
+      results: rows.map(r => ({
+        id: r.id,
+        type: r.type,
+        title: r.title || null,
+        lesson_learned: r.lesson_learned || null,
+        importance: r.importance ?? null,
+        project: r.project,
+        created_at: r.created_at,
+        created_at_epoch: r.created_at_epoch,
+      })),
+    }));
+    return;
+  }
+
   if (rows.length === 0) {
     out(`[mem] No history for "${filename}"`);
     return;
   }
 
-  // Update access_count for recalled observations (aligned with MCP mem_recall)
-  const recalledIds = rows.map(r => r.id);
-  const recallPh = recalledIds.map(() => '?').join(',');
-  try {
-    db.prepare(`UPDATE observations SET access_count = COALESCE(access_count, 0) + 1, last_accessed_at = ? WHERE id IN (${recallPh})`).run(Date.now(), ...recalledIds);
-  } catch { /* non-critical: FTS5 trigger may fail on corrupted index */ }
-
   out(`[mem] History for ${filename} (${rows.length}):`);
   for (const r of rows) {
     const title = truncate(r.title || '(untitled)', 80);
@@ -635,6 +673,15 @@ function cmdTimeline(db, args) {
   const before = parseWindow('before', flags.before);
   const after = parseWindow('after', flags.after);
   const project = flags.project ? resolveProject(db, flags.project) : null;
+  const jsonOutput = flags.json === true || flags.json === 'true';
+
+  const toRow = r => ({
+    id: r.id,
+    type: r.type,
+    title: r.title || r.subtitle || null,
+    created_at: r.created_at,
+    created_at_epoch: r.created_at_epoch,
+  });
 
   // Parse --anchor, accepting P#/S#/# prefix so callers can paste search-result IDs verbatim.
   // For prompt/session anchors, resolve to the nearest-in-time observation so timeline semantics
@@ -745,6 +792,18 @@ function cmdTimeline(db, args) {
       LIMIT ?
     `).all(...fallbackParams);
 
+    if (jsonOutput) {
+      out(JSON.stringify({
+        anchor: null,
+        anchor_note: queryStr ? `no anchor matched query "${queryStr}"` : null,
+        before: [],
+        after: [],
+        fallback: 'recent',
+        results: rows.map(toRow),
+      }));
+      return;
+    }
+
     if (rows.length === 0) {
       out('[mem] No observations found.');
       return;
@@ -800,6 +859,16 @@ function cmdTimeline(db, args) {
     'SELECT id, type, title, subtitle, created_at, created_at_epoch FROM observations WHERE id = ?'
   ).get(anchorId);
 
+  if (jsonOutput) {
+    out(JSON.stringify({
+      anchor: toRow(anchor),
+      anchor_note: anchorNote,
+      before: beforeRows.reverse().map(toRow),
+      after: afterRows.map(toRow),
+    }));
+    return;
+  }
+
   const all = [...beforeRows.reverse(), anchor, ...afterRows];
 
   out(`[mem] Timeline around #${anchorId}${anchorNote ? ' ' + anchorNote : ''}:`);
@@ -887,12 +956,18 @@ async function renderQualityReport(db, { project, days }) {
 async function cmdStats(db, args) {
   const { flags } = parseArgs(args);
   const project = flags.project ? resolveProject(db, flags.project) : null;
-  const days = parseInt(flags.days, 10) || 30;
+  const days = parseIntFlag(flags.days, { name: '--days', defaultValue: 30, max: 3650 });
+  const jsonOutput = flags.json === true || flags.json === 'true';
   // N-1: --quality routes to a separate quality-focused report (lesson rate,
   // LOW_SIGNAL rate, per-type hit+lesson %, R-2 watchdog targets). Intended as
   // the baseline metric dashboard for the future Haiku prompt A/B test.
   const quality = flags.quality === true || flags.quality === 'true';
   if (quality) {
+    if (jsonOutput) {
+      const { computeQualityStats } = await import('./lib/stats-quality.mjs');
+      out(JSON.stringify(computeQualityStats(db, { project, days })));
+      return;
+    }
     await renderQualityReport(db, { project, days });
     return;
   }
@@ -1012,6 +1087,39 @@ async function cmdStats(db, args) {
   `).all(...tdParams, ...baseParams);
   const tierMap = Object.fromEntries(tierDist.map(r => [r.tier, r.c]));
 
+  if (jsonOutput) {
+    out(JSON.stringify({
+      project,
+      days,
+      totals: {
+        observations: obsTotal.c,
+        sessions: sessTotal.c,
+        prompts: promptTotal.c,
+      },
+      recent: {
+        observations: obsRecent.c,
+        sessions: sessRecent.c,
+      },
+      type_distribution: types.map(t => ({ type: t.type, count: t.c })),
+      top_projects: projects.map(p => ({ project: p.project, count: p.c })),
+      daily_activity: daily.map(d => ({ day: d.day, count: d.c })),
+      data_health: {
+        estimated_tokens: tokenEst.t ?? 0,
+        avg_importance: Number((avgImp.v ?? 1).toFixed(2)),
+        low_value_count: lowVal.c,
+        noise_ratio: Number(noiseRatio.toFixed(4)),
+        compressed: compressedCount.c,
+        superseded_only: supersededOnlyCount.c,
+      },
+      tier_distribution: {
+        working: tierMap.working ?? 0,
+        active: tierMap.active ?? 0,
+        archive: tierMap.archive ?? 0,
+      },
+    }));
+    return;
+  }
+
   out(`[mem] Stats${project ? ` (${project})` : ''}:`);
   out(`Total: ${obsTotal.c.toLocaleString()} observations | ${sessTotal.c} sessions | ${promptTotal.c} prompts`);
   out(`Last ${days}d: ${obsRecent.c} observations | ${sessRecent.c} sessions`);
@@ -1093,8 +1201,8 @@ function cmdBrowse(db, args) {
     fail(`[mem] Invalid tier: "${tierFilter}". Use: working, active, or archive`);
     return;
   }
-  const rawLimit = flags.limit !== undefined ? parseInt(flags.limit, 10) : NaN;
-  const limit = Number.isInteger(rawLimit) ? Math.max(1, rawLimit) : (tierFilter ? 20 : 5);
+  const limit = parseIntFlag(flags.limit, { name: '--limit', defaultValue: tierFilter ? 20 : 5, max: 1000 });
+  const jsonOutput = flags.json === true || flags.json === 'true';
   const now = Date.now();
 
   const ctx = {
@@ -1108,10 +1216,12 @@ function cmdBrowse(db, args) {
   const tierLabels = { working: '🔴 Working Memory', active: '🟡 Active Memory', archive: '🔵 Archive' };
   const showTiers = tierFilter ? [tierFilter] : tiers;
 
-  out(`📊 Memory Dashboard (${project})\n`);
-
-  let grandTotal = 0;
+  // Collect data first (for JSON), then format. The text path also prints
+  // tier headers as it walks; refactored to two passes so the JSON shape can
+  // include row arrays alongside totals.
+  const tierData = {};
   const tierCounts = {};
+  let grandTotal = 0;
 
   for (const tier of showTiers) {
     const countRow = db.prepare(`
@@ -1124,24 +1234,62 @@ function cmdBrowse(db, args) {
     tierCounts[tier] = count;
     grandTotal += count;
 
-    out(`${tierLabels[tier]} (${count})`);
-
-    if (tier === 'archive' && !tierFilter) {
-      if (count > 0) out('');
+    // Archive in unfiltered view: keep count but skip row fetch (matches text path).
+    const skipRows = tier === 'archive' && !tierFilter;
+    if (count === 0 || skipRows) {
+      tierData[tier] = { count, rows: [] };
       continue;
     }
 
-    if (count === 0) { out(''); continue; }
-
     const rows = db.prepare(`
       SELECT * FROM (
-        SELECT id, type, title, created_at_epoch, ${TIER_CASE_SQL} as tier
+        SELECT id, type, title, importance, created_at_epoch, created_at, ${TIER_CASE_SQL} as tier
         FROM observations
         WHERE project = ? AND COALESCE(compressed_into, 0) = 0 AND superseded_at IS NULL
       ) WHERE tier = ?
       ORDER BY created_at_epoch DESC
       LIMIT ?
     `).all(...params, project, tier, limit);
+    tierData[tier] = { count, rows };
+  }
+
+  if (jsonOutput) {
+    const tiersOut = {};
+    for (const tier of showTiers) {
+      tiersOut[tier] = {
+        count: tierData[tier].count,
+        results: tierData[tier].rows.map(r => ({
+          id: r.id,
+          type: r.type,
+          title: r.title || null,
+          importance: r.importance ?? null,
+          created_at: r.created_at,
+          created_at_epoch: r.created_at_epoch,
+        })),
+      };
+    }
+    out(JSON.stringify({
+      project,
+      limit,
+      tier_filter: tierFilter,
+      totals: { ...tierCounts, grand_total: grandTotal },
+      tiers: tiersOut,
+    }));
+    return;
+  }
+
+  out(`📊 Memory Dashboard (${project})\n`);
+
+  for (const tier of showTiers) {
+    const { count, rows } = tierData[tier];
+    out(`${tierLabels[tier]} (${count})`);
+
+    if (tier === 'archive' && !tierFilter) {
+      if (count > 0) out('');
+      continue;
+    }
+
+    if (count === 0) { out(''); continue; }
 
     for (const r of rows) {
       out(`  #${r.id} ${typeIcon(r.type)} [${r.type}] ${truncate(r.title || '(untitled)', 80)} | ${relativeTime(r.created_at_epoch)}`);
@@ -1351,8 +1499,7 @@ function cmdExport(db, args) {
     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;
-  const limit = Math.min(Number.isInteger(rawLimit) ? Math.max(1, rawLimit) : 200, 1000);
+  const limit = parseIntFlag(flags.limit, { name: '--limit', defaultValue: 200, max: 1000 });
   const format = flags.format || 'json';
   if (!['json', 'jsonl'].includes(format)) {
     fail(`[mem] Invalid format "${format}". Use: json or jsonl`);
@@ -1829,8 +1976,7 @@ function cmdRegistry(_memDb, args) {
 
     if (action === 'list') {
       const typeFilter = flags.type;
-      const rawLimit = parseInt(flags.limit, 10);
-      const listLimit = Number.isInteger(rawLimit) && rawLimit > 0 ? rawLimit : 20;
+      const listLimit = parseIntFlag(flags.limit, { name: '--limit', defaultValue: 20, max: 1000 });
       const where = typeFilter ? 'WHERE type = ? AND status = ?' : 'WHERE status = ?';
       const params = typeFilter ? [typeFilter, 'active'] : ['active'];
       const allResources = rdb.prepare(`
@@ -1996,11 +2142,14 @@ Commands:
     --json              Output as JSON: {query,total,returned,offset,limit,results:[…]}
 
   recent [N]            Show N most recent observations (default 10)
+    --limit N           Sibling-parity alias for [N] (max 1000)
     --project P         Filter by project
+    --json              Output as JSON: {project,limit,total,results:[…]}
 
   recall <file>         Show observations related to a file
     --limit N           Max results (default 10)
     --include-noise     Include hook-llm fallback titles ("Modified X", raw error logs)
+    --json              Output as JSON: {file,limit,include_noise,total,results:[…]}
 
   get <id1,id2,...>     Get full details by ID
     IDs accept search-output prefixes: #123 (obs), P#123 (prompt), S#123 (session).
@@ -2019,6 +2168,8 @@ Commands:
     --before N          Show N before anchor (default 5)
     --after N           Show N after anchor (default 5)
     --project P         Filter by project
+    --json              Output as JSON: {anchor,anchor_note,before:[…],after:[…]}
+                        (or {anchor:null,fallback:"recent",results:[…]} when no anchor)
 
   save "<text>"         Save a new observation
     --type T            Observation type (default: discovery)
@@ -2076,6 +2227,10 @@ Commands:
     --days N            Lookback window (default 30)
     --quality           Quality dashboard: lesson rate, LOW_SIGNAL rate, per-type
                         hit/lesson %, top-accessed lessons, R-2 watchdog targets
+    --json              Output as JSON: nested by section
+                        ({totals,recent,type_distribution,top_projects,
+                          daily_activity,data_health,tier_distribution})
+                        or quality shape when --quality --json combined
 
   context               Show current CLAUDE.md context block
     --json              Output as structured JSON
@@ -2084,6 +2239,9 @@ Commands:
     --tier T            Filter: working|active|archive
     --project P         Filter by project
     --limit N           Max entries per tier (default 5)
+    --json              Output as JSON: {project,limit,tier_filter,
+                          totals:{working,active,archive,grand_total},
+                          tiers:{working:{count,results:[…]}, …}}
 
   registry <action>     Manage tool resource registry
     list                List resources [--type skill|agent] [--limit N] (default 20)
@@ -2098,6 +2256,7 @@ Commands:
     search "<query>"    Search events [--type T] [--limit N] [--project P]
     recent [N]          Most recent events [--type T] [--project P]
     show <id>           Show full event row by id
+    delete <id1,id2,…>  Delete events by ID (preview by default; use --confirm to execute)
 
     Valid types: bugfix, lesson, bug, discovery, refactor, feature, observation, decision
     --files (plural, comma-split) preferred; --file (singular) kept for back-compat.
@@ -2332,7 +2491,9 @@ export async function run(argv) {
   // that doesn't honor it. Stdout output and exit code are unchanged so existing
   // text-parsing callers keep working — the note lives in stderr for scripts to
   // detect the gap.
-  const JSON_SUPPORTED_CMDS = new Set(['search', 'context']);
+  const JSON_SUPPORTED_CMDS = new Set([
+    'search', 'context', 'recent', 'recall', 'timeline', 'stats', 'browse', 'export',
+  ]);
   if (cmdArgs.includes('--json') && !JSON_SUPPORTED_CMDS.has(cmd)) {
     process.stderr.write(`[mem] Note: --json is supported only on: ${[...JSON_SUPPORTED_CMDS].join(', ')}. "${cmd}" outputs text.\n`);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "2.66.0",
+  "version": "2.69.0",
   "description": "Lightweight persistent memory system for Claude Code",
   "type": "module",
   "packageManager": "npm@10.9.2",
@@ -45,6 +45,7 @@
     "adopt-cli.mjs",
     "haiku-client.mjs",
     "lib/activity.mjs",
+    "lib/cli-flags.mjs",
     "lib/git-state.mjs",
     "lib/task-reader.mjs",
     "lib/plan-reader.mjs",

package/source-files.mjs

@@ -29,6 +29,7 @@ export const SOURCE_FILES = [
   // lib/ — statically imported by hook-llm.mjs (activity) + hook-handoff.mjs (git-state, task-reader);
   // dynamically imported by hook.mjs (startup-dashboard) + mem-cli.mjs (doctor-benchmark, plan-reader).
   'lib/activity.mjs',
+  'lib/cli-flags.mjs',
   'lib/task-reader.mjs',
   'lib/plan-reader.mjs',
   'lib/git-state.mjs',

package/utils.mjs

@@ -324,6 +324,48 @@ export function isSpecificTerm(token) {
   return token.length >= 4 && !/^\d+$/.test(token);
 }
 
+/**
+ * Detect prompts whose content is purely workflow/control language with no
+ * subject substance — "继续", "提交代码", "/exit", "commit and push", etc.
+ *
+ * Rationale: `buildAndSaveHandoff` writes user-prompt text into `working_on`
+ * verbatim. When a session's only prompt is a meta-trigger, the resumed
+ * session sees `Working On: 继续前面的工作` — self-referential garbage. This
+ * detector lets the writer filter such prompts before they pollute the field.
+ *
+ * Strategy: strip a curated set of trigger keywords (zh + en) plus
+ * punctuation; if <4 chars of substantive content remain, the prompt is meta.
+ * Threshold tuned against real `user_prompts` samples — keeps prompts like
+ * "提交代码，发新版本，检查线上有没有错误" (real verification subject) while
+ * dropping bare "/exit" / "继续" / "commit".
+ *
+ * @param {string} text Prompt text
+ * @returns {boolean} true if the prompt is meta-trigger only
+ */
+export function isMetaTriggerPrompt(text) {
+  if (!text || typeof text !== 'string') return true;
+  const trimmed = text.trim();
+  if (trimmed.length === 0) return true;
+
+  const stripped = trimmed
+    .replace(/继续(前面|之前|刚才|上次)?(的)?(工作|任务|话题|讨论)?/g, '')
+    .replace(/提交(代码|了|完|过)?(并)?(发布)?/g, '')
+    .replace(/退出/g, '')
+    .replace(/发(布|新版本|个新版本)/g, '')
+    .replace(/新开(了)?(一个)?(会话|session)?/g, '')
+    .replace(/保存(进度|状态|工作|代码)?/g, '')
+    .replace(/接着(干|做|来|继续)?/g, '')
+    .replace(/上次(到哪了|说到哪了)?/g, '')
+    .replace(/总结一下|复盘一下/g, '')
+    .replace(/前面(的)?(工作|话题|讨论|内容)/g, '')
+    .replace(/\/?(clear|exit)\b/gi, '')
+    .replace(/\b(commit|continue|resume|push|save|restart|exit|next)\b/gi, '')
+    .replace(/[，,。.!！?？:：;；()（）【】[\]\s/\\-]+/g, '')
+    .trim();
+
+  return stripped.length < 4;
+}
+
 /**
  * Extract match keywords from text and file paths for handoff intent matching.
  * @param {string} text Combined text from prompts, observations, etc.