claude-mem-lite 3.74.0 → 3.75.0

package/lib/doctor-drift.mjs

@@ -82,9 +82,16 @@ export function checkDevDrift(installDir, sourceFiles) {
 // stale in silence: tests/doctor-hook-script-manifest.test.mjs re-derives it from the
 // `command` strings in hooks/hooks.json and asserts equality, so registering a new hook
 // script without classifying it here goes red.
+//
+// `pre-agent-inject.js` moved OUT of this set on 2026-08-22 (audit P2-5): no command line
+// names it any more — `pre-agent-inject.sh` does, and execs the .js only when the feature
+// is switched on. It is still shipped and still executed, so `checkHookScriptDrift` keeps
+// grading it; it now reports as the module class, whose message ("ERR_MODULE_NOT_FOUND at
+// hook time") is the truer description of what its absence does. Same severity either way,
+// which is why this set is documented as driving the MESSAGE, not the grade.
 export const HOOK_SCRIPT_ENTRY_POINTS = new Set([
   'post-tool-use.sh', 'user-prompt-search.js', 'pre-tool-recall.js',
-  'post-tool-recall.js', 'pre-skill-bridge.js', 'pre-agent-inject.js',
+  'post-tool-recall.js', 'pre-skill-bridge.js', 'pre-agent-inject.sh',
   'hook-launcher.mjs',
 ]);
 

package/lib/fast-summary.mjs

@@ -0,0 +1,87 @@
+// The non-LLM session summary — one shape, three callers.
+//
+// Audit 2026-08-22 P2-9. hook.mjs carried three hand-copied versions of "read this
+// session's first prompt and its last few observation titles, scrub them, insert a
+// session_summaries row": the Stop-time fast path, the SessionStart previous-session
+// path, and the SessionStart /exit-restart fallback. They had already drifted — the
+// 13-column INSERT was retyped each time, and the truncation limits split 600/600/400
+// against 300/200. Copy-and-miss on exactly this kind of triplicate is what broke
+// v3.35.2, and the comment in one of these blocks announcing "parity with the other"
+// is the tell that parity was being maintained by hand.
+//
+// NOT collapsed in here: hook-llm.mjs's summary insert. That row is produced by the
+// model and carries two more columns (lessons, key_decisions); it is a different
+// record that happens to share a table, and merging it would mean inventing a shape
+// that fits neither.
+import { scrubRecord } from './scrub-record.mjs';
+import { truncate } from '../format-utils.mjs';
+
+/** Column list + placeholder row, written once. */
+const INSERT_SQL = `
+  INSERT INTO session_summaries
+  (memory_session_id, project, request, investigated, learned, completed, next_steps,
+   remaining_items, files_read, files_edited, notes, created_at, created_at_epoch)
+  VALUES (?, ?, ?, '', '', ?, '', ?, '[]', '[]', ?, ?, ?)
+`;
+
+/**
+ * Per-caller truncation limits. These are NOT unified on purpose: the Stop path stores
+ * roughly twice what the two SessionStart paths do, and every one of these strings is
+ * re-injected into a later session's context. Collapsing them to one number changes how
+ * much text the product injects, which is a measurable behaviour change and not
+ * something a refactor gets to decide. Passed explicitly so the difference is visible
+ * at the call site instead of living in three retyped `truncate(...)` arguments.
+ */
+export const FAST_SUMMARY_LIMITS = {
+  stop:         { request: 200, completed: 600, remaining: 600, notes: 400 },
+  sessionStart: { request: 200, completed: 300, remaining: 200, notes: 400 },
+  exitRestart:  { request: 200, completed: 300, remaining: 200, notes: 400 },
+};
+
+/**
+ * The two reads every fast summary is built from: the session's opening prompt, and the
+ * titles of its most recent observations.
+ * @returns {{request: string, completed: string}} raw (unscrubbed, untruncated) values
+ */
+export function readFastSummarySource(db, sessionId) {
+  const firstPrompt = db.prepare(`
+    SELECT prompt_text FROM user_prompts
+    WHERE content_session_id = ?
+    ORDER BY prompt_number ASC LIMIT 1
+  `).get(sessionId);
+  const recentObs = db.prepare(`
+    SELECT title FROM observations
+    WHERE memory_session_id = ? AND COALESCE(compressed_into, 0) = 0
+    ORDER BY created_at_epoch DESC LIMIT 5
+  `).all(sessionId);
+  return {
+    request: firstPrompt?.prompt_text || '',
+    completed: recentObs.map((o) => o.title).filter(Boolean).join('; '),
+  };
+}
+
+/**
+ * Scrub, truncate, insert. Raw values go into scrubRecord and truncation happens after,
+ * at the bind site — a secret straddling the truncation boundary would otherwise fall
+ * below scrubSecrets' length floors and survive into the row (privacy review, v3.x).
+ * That ordering is the reason this function exists in one copy.
+ *
+ * @param {{request?: string, completed?: string, remaining?: string, notes?: string}} values raw
+ * @param {{request: number, completed: number, remaining: number, notes: number}} limits
+ */
+export function insertFastSummary(db, { sessionId, project, values, limits, now }) {
+  const safe = scrubRecord('session_summaries', {
+    request: values.request || '',
+    completed: values.completed || '',
+    remaining_items: values.remaining || '',
+    notes: values.notes || 'fast',
+  });
+  db.prepare(INSERT_SQL).run(
+    sessionId, project,
+    truncate(safe.request, limits.request),
+    truncate(safe.completed, limits.completed),
+    truncate(safe.remaining_items, limits.remaining),
+    truncate(safe.notes, limits.notes),
+    now.toISOString(), now.getTime(),
+  );
+}

package/lib/get-core.mjs

@@ -15,6 +15,41 @@ export const OBS_FIELDS = ['id', 'type', 'title', 'subtitle', 'narrative', 'text
  *  6-field subset made notes/remaining_items/files_* searchable-but-unrenderable. */
 export const SESSION_DETAIL_FIELDS = ['id', 'request', 'investigated', 'learned', 'completed', 'next_steps', 'remaining_items', 'files_read', 'files_edited', 'notes', 'project', 'created_at', 'memory_session_id', 'prompt_number'];
 
+/** User-prompt detail render set. The CLI face rendered only prompt_text +
+ *  content_session_id while MCP rendered prompt_number and created_at too — the same
+ *  searchable-but-invisible shape SESSION_DETAIL_FIELDS was created to close, reopened on
+ *  the prompt source (audit 2026-08-22, P2-6). */
+export const PROMPT_DETAIL_FIELDS = ['id', 'prompt_text', 'content_session_id', 'prompt_number', 'created_at'];
+
+/** Event detail render set. `body` carries the distilled lesson persistHaikuSummary
+ *  writes (lesson_learned || narrative). */
+export const EVENT_DETAIL_FIELDS = ['id', 'event_type', 'title', 'body', 'project', 'importance', 'file_paths', 'git_sha', 'created_at'];
+
+/**
+ * Fetch user-prompt detail rows, oldest-first.
+ * No access bump: prompts are not ranked, so reading one is not a usage signal.
+ */
+export function fetchPromptDetail(db, ids) {
+  const ph = ids.map(() => '?').join(',');
+  return db.prepare(`SELECT * FROM user_prompts WHERE id IN (${ph}) ORDER BY created_at_epoch ASC`).all(...ids);
+}
+
+/**
+ * Fetch event detail rows, oldest-first.
+ *
+ * The events table has no `created_at` ISO column — only `created_at_epoch`. Both faces
+ * used to derive the ISO string themselves; deriving it once here means EVENT_DETAIL_FIELDS
+ * can name `created_at` like every other field set and neither face special-cases it.
+ */
+export function fetchEventDetail(db, ids) {
+  const ph = ids.map(() => '?').join(',');
+  const rows = db.prepare(`SELECT * FROM events WHERE id IN (${ph}) ORDER BY created_at_epoch ASC`).all(...ids);
+  return rows.map(r => ({
+    ...r,
+    created_at: r.created_at_epoch ? new Date(r.created_at_epoch).toISOString() : null,
+  }));
+}
+
 /**
  * Fetch observation detail rows: bump access_count/last_accessed_at (reading a
  * detail IS an access signal — feeds noisePenalty's ratio guard), run the

package/lib/maintain-core.mjs

@@ -12,7 +12,7 @@
 // auto-maintain block). `ctx` carries the per-caller knobs:
 //   { projectFilter: 'AND project = ?' | '', baseParams: [project?] , staleAge, opCap }
 
-import { COMPRESSED_PENDING_PURGE, computeMinHash, estimateJaccardFromMinHash, jaccardSimilarity } from '../utils.mjs';
+import { COMPRESSED_AUTO, COMPRESSED_PENDING_PURGE, computeMinHash, estimateJaccardFromMinHash, jaccardSimilarity } from '../utils.mjs';
 import { rebuildVocabulary, computeVector, _resetVocabCache, vectorsEnabled, vecTextForRow } from '../tfidf.mjs';
 import { DEDUP_JACCARD_THRESHOLD, MINHASH_PRE_THRESHOLD as MINHASH_PRE_THRESHOLD_SRC, FUZZY_DEDUP_THRESHOLD, FUZZY_BODY_THRESHOLD, MINHASH_PREFILTER } from './dedup-constants.mjs';
 import { liveObsFilterSql } from './inject-search-core.mjs';
@@ -81,6 +81,100 @@ export function selectFuzzyDedupeIds(rows, {
   return removeIds;
 }
 
+/**
+ * Tombstone the ids an auto-dedup pass selected.
+ *
+ * `AND superseded_at IS NULL` is the load-bearing half. Both dedup channels select live
+ * rows and then stamp them, and between those two steps another writer can supersede a
+ * row — `save --supersedes=[#A]` writes A.superseded_by = B's NUMERIC id, and the chain
+ * citation-tracker's decay hand-off and timeline re-anchoring both follow. An unguarded
+ * UPDATE overwrites that numeric chain with the string marker and the chain silently dead-
+ * ends. The window is narrow and the failure is not reproducible on demand, which is
+ * exactly why it survived seven rounds of this invariant being re-broken.
+ *
+ * The exact channel grew this guard in v3.63; the fuzzy channel did not, and the audit of
+ * 2026-08-22 (P2-1) found the asymmetry still open. Both channels now stamp through this
+ * one function, so the guard cannot be present on one and missing on the other.
+ *
+ * @param {object} db open DB handle
+ * @param {number[]} ids observation ids selected for superseding
+ * @param {string} marker superseded_by value ('auto-dedup' | 'auto-dedup-fuzzy')
+ * @returns {number} rows actually stamped — less than ids.length means the guard held
+ */
+export function stampDedupSuperseded(db, ids, marker) {
+  if (!Array.isArray(ids) || ids.length === 0) return 0;
+  const ph = ids.map(() => '?').join(',');
+  const res = db.prepare(
+    `UPDATE observations SET superseded_at = ?, superseded_by = ?
+     WHERE id IN (${ph}) AND superseded_at IS NULL`
+  ).run(Date.now(), marker, ...ids);
+  return res.changes;
+}
+
+/**
+ * Mark auto-compressible observations for one project — the two full-table conditional
+ * UPDATEs that used to run inside the SessionStart transaction on every single boot
+ * (audit 2026-08-22, P2-11). They are maintenance by definition: nothing about a new
+ * session makes a 30-day-old row newly compressible, and the same 24h auto-maintain gate
+ * that guards decay/purge/backup was already sitting right next to them.
+ *
+ * Both predicates are unchanged, including the project scope — this moves *when* the
+ * marking runs, not *what* it marks.
+ *
+ * @param {object} db open DB handle
+ * @param {string} project project scope (unchanged from the SessionStart behavior)
+ * @param {object} [opts]
+ * @param {number} [opts.agedAgeMs] age floor for the general 30d pass
+ * @param {number} [opts.noiseAgeMs] age floor for the accelerated 7d LOW_SIGNAL pass
+ * @returns {{aged: number, noise: number}} rows marked by each pass
+ */
+export function markAutoCompressible(db, project, {
+  agedAgeMs = 30 * DAY_MS,
+  noiseAgeMs = 7 * DAY_MS,
+} = {}) {
+  if (!project) return { aged: 0, noise: 0 };
+  const now = Date.now();
+
+  // v2.56.0 #4: protect injection_count > 0 obs (proven contextually relevant via
+  // hook-memory injection, even if the user never explicitly fetched them).
+  // `<= 1` (was `= 1`): citation-decay floors importance at 0 and the LLM low-signal
+  // filter saves at imp=0 — those rows are STRICTLY lower value than imp=1 yet escaped
+  // GC, accumulating to ~40% of a mature DB (immortal: hidden from injection by the
+  // imp>=1 floor, but visible as explicit-search noise).
+  // v3.23: never auto-hide a row that carries a real lesson — compression folds sources
+  // into a title-only summary (lesson lost) and COMPRESSED_AUTO hides the row from search
+  // entirely (audit: 62 lessons buried this way).
+  const aged = db.prepare(`
+    UPDATE observations SET compressed_into = ${COMPRESSED_AUTO}
+    WHERE COALESCE(compressed_into, 0) = 0
+      AND COALESCE(importance, 1) <= 1
+      AND COALESCE(injection_count, 0) = 0
+      AND (lesson_learned IS NULL OR lesson_learned = '' OR lesson_learned = 'none')
+      AND created_at_epoch < ?
+      AND project = ?
+  `).run(now - agedAgeMs, project).changes;
+
+  // v2.47 P0-3: accelerated pass for LOW_SIGNAL + no-signal noise — 7 days instead of 30.
+  // The write-side capNoiseImportance already forces imp=1 on these; this only shrinks GC
+  // latency so the corpus reduction materializes within a week instead of bleeding into
+  // the 30-day tier.
+  const noise = db.prepare(`
+    UPDATE observations SET compressed_into = ${COMPRESSED_AUTO}
+    WHERE COALESCE(compressed_into, 0) = 0
+      AND COALESCE(importance, 1) <= 1
+      AND (lesson_learned IS NULL OR lesson_learned = '' OR lesson_learned = 'none')
+      AND (facts IS NULL OR facts = '' OR facts = '[]')
+      AND (
+        title LIKE 'Modified %' OR title LIKE 'Worked on %'
+        OR title LIKE 'Reviewed %' OR title LIKE 'Error%'
+      )
+      AND created_at_epoch < ?
+      AND project = ?
+  `).run(now - noiseAgeMs, project).changes;
+
+  return { aged, noise };
+}
+
 /** Delete broken observations (no title AND no narrative). Returns rows deleted. */
 // Before hard-deleting observations, un-hide any rows merged INTO them. A child has
 // compressed_into = <keeperId>; deleting that keeper (compressed_into has no FK) would

package/lib/registry-core.mjs

@@ -0,0 +1,94 @@
+// Shared body for the registry write actions — import / remove / reindex.
+//
+// These were the last un-collapsed CLI/MCP twin (audit 2026-08-22 P1-3): mem-cli.mjs and
+// server.mjs each wrote their own SQL for the same three actions, and had already drifted —
+// the CLI granted a user-initiated import `quality_tier = 'installed'` and the MCP twin did
+// not, so the same intent produced differently-ranked rows depending on which surface the
+// user reached for. That is this project's first-listed病类 ("a guard wired into one face,
+// missing on the other"), so the fix is a single body both faces call, not a second patch.
+//
+// Contract: these functions decide and write. They return structured results and never
+// format output or touch process state — rendering (and CLI-only concerns like bare-flag
+// rejection or the "add --capability-summary" tip) stays in the surface.
+
+import { upsertResource } from '../registry.mjs';
+
+/**
+ * String columns an import may set, in canonical snake_case. Single source: the CLI derives
+ * its kebab-case flag names from this list, the MCP tool reads its args by these keys, so a
+ * new column is added once and both surfaces pick it up.
+ */
+export const IMPORT_STRING_FIELDS = [
+  'repo_url',
+  'local_path',
+  'invocation_name',
+  'intent_tags',
+  'domain_tags',
+  'trigger_patterns',
+  'capability_summary',
+  'keywords',
+  'tech_stack',
+  'use_cases',
+];
+
+/**
+ * Resolve the `source` column for an import.
+ *
+ * Preserve provenance on a metadata-only re-import: default to 'user' only for a genuinely
+ * NEW resource. Re-importing an existing github/preinstalled row without an explicit source
+ * must not flip it to 'user' (which also mis-grants the user-source rank boost).
+ */
+function resolveSource(db, { type, name, source }) {
+  if (source) return source;
+  const existing = db.prepare('SELECT source FROM resources WHERE type = ? AND name = ?').get(type, name);
+  return existing ? existing.source : 'user';
+}
+
+/**
+ * Upsert one resource.
+ *
+ * @param {object} db  open resource-registry.db handle
+ * @param {object} params
+ * @param {string} params.name
+ * @param {string} params.type              'skill' | 'agent'
+ * @param {string} [params.source]          explicit provenance; absent = user-initiated
+ * @param {object} [params.fields]          IMPORT_STRING_FIELDS values (snake_case keys)
+ * @returns {{id: number, source: string, installedTierGranted: boolean}}
+ */
+export function importResource(db, { name, type, source, fields = {} }) {
+  const resolvedSource = resolveSource(db, { type, name, source });
+
+  const row = { name, type, status: 'active', source: resolvedSource };
+  for (const f of IMPORT_STRING_FIELDS) row[f] = fields[f] || '';
+
+  const id = upsertResource(db, row);
+
+  // A user-initiated import (no explicit --source/source arg) means the user deliberately
+  // added this resource — it gets the 'installed' quality tier, which the retriever reads as
+  // a ranking bonus and the recommendation gate reads as a precision signal.
+  const installedTierGranted = Boolean(id) && !source;
+  if (installedTierGranted) {
+    db.prepare("UPDATE resources SET quality_tier = 'installed' WHERE id = ?").run(id);
+  }
+
+  return { id, source: resolvedSource, installedTierGranted };
+}
+
+/**
+ * Delete one resource.
+ * @returns {{removed: boolean}} removed=false means nothing matched (not an error).
+ */
+export function removeResource(db, { name, type }) {
+  const result = db.prepare('DELETE FROM resources WHERE type = ? AND name = ?').run(type, name);
+  return { removed: result.changes > 0 };
+}
+
+/**
+ * Rebuild the FTS5 index over the resources table.
+ * @returns {{activeCount: number}}
+ */
+export function reindexResources(db) {
+  db.exec("INSERT INTO resources_fts(resources_fts) VALUES('rebuild')");
+  const row = db.prepare('SELECT COUNT(*) as c FROM resources WHERE status = ?').get('active');
+  return { activeCount: row.c };
+}

package/lib/resolve-data-dir.mjs

@@ -13,8 +13,57 @@
 //   - A relative path silently resolves against each process's cwd, scattering
 //     state across directories.
 // Falsy (unset/empty) is the only non-absolute value we treat as "use default".
-import { homedir } from 'node:os';
-import { join, isAbsolute } from 'node:path';
+import { homedir, tmpdir } from 'node:os';
+import { join, isAbsolute, resolve } from 'node:path';
+
+/**
+ * Test-run containment (audit 2026-08-22 P2-4).
+ *
+ * vitest.config.mjs clears CLAUDE_MEM_DIR for every worker, which stops a relocated
+ * dev DB from being read — but it cannot stop a test that never sets the var at all:
+ * that test simply resolves the DEFAULT, and the default is the maintainer's real
+ * `~/.claude-mem-lite`. It is not hypothetical. During the v3.73.0 release a test
+ * wrote a `rateLimited` marker into the live data dir, because the module computed
+ * its path at import time and the test's later env stub arrived too late.
+ *
+ * The guard rides the same channel as the leak: a subprocess that inherits
+ * `...process.env` (how e2e tests spawn hooks, and how the var goes missing in the
+ * first place) also inherits CLAUDE_MEM_TEST_GUARD, so the redirect follows it there.
+ * A subprocess given a curated env has to pass CLAUDE_MEM_DIR explicitly and is safe
+ * by construction.
+ *
+ * It REDIRECTS rather than throws, deliberately. Throwing was tried first and took 181
+ * of 289 test files down at collection: schema.mjs resolves the dir at IMPORT time, so
+ * every test that imports it — including the hundreds that then use `:memory:` and never
+ * touch a file — would have to opt out of a guard they never needed. "Imported the
+ * module" is not the failure; "wrote to the real directory" is, and a redirect makes
+ * that one impossible while leaving the import harmless.
+ *
+ * The redirect target is shared per run (CLAUDE_MEM_TEST_SANDBOX, set by
+ * tests/global-setup.mjs) so a parent and the subprocess it spawns still agree on one
+ * directory — the same reason the ambient env is inherited at all.
+ *
+ * Escape hatch: CLAUDE_MEM_TEST_GUARD=off, for a test that must exercise real default
+ * resolution. It should be rare and it should say why.
+ */
+function containInTests(dir) {
+  if (process.env.CLAUDE_MEM_TEST_GUARD !== '1') return dir;
+  // Block ONE directory: the real one. "Anywhere outside os.tmpdir()" was tried first
+  // and was wrong twice over — fixtures hardcode '/tmp' while os.tmpdir() follows
+  // $TMPDIR (relocated under $HOME by a sandboxed shell), and several suites keep their
+  // scratch DB inside the repo at tests/.tmp-*. Both are isolated; neither is the leak.
+  // The leak is always the same shape: nobody set CLAUDE_MEM_DIR, so the DEFAULT
+  // resolved, and the default is the developer's live database.
+  //
+  // Compared against the path captured by tests/global-setup.mjs BEFORE the suite
+  // relocated anything, not against homedir() — several suites deliberately run with
+  // HOME pointed at a fixture, and re-deriving the default here would redirect exactly
+  // those legitimate cases while missing the real dir once HOME moved.
+  const real = process.env.CLAUDE_MEM_TEST_REALDIR || join(homedir(), '.claude-mem-lite');
+  if (resolve(dir) !== resolve(real)) return dir;
+  const sandbox = process.env.CLAUDE_MEM_TEST_SANDBOX;
+  return sandbox && isAbsolute(sandbox) ? sandbox : join(resolve(tmpdir()), 'claude-mem-test-fallback');
+}
 
 /**
  * @param {string|undefined|null} raw  Typically process.env.CLAUDE_MEM_DIR.
@@ -23,7 +72,7 @@ import { join, isAbsolute } from 'node:path';
  */
 export function resolveDataDir(raw) {
   if (raw === undefined || raw === null || raw === '') {
-    return join(homedir(), '.claude-mem-lite');
+    return containInTests(join(homedir(), '.claude-mem-lite'));
   }
   if (typeof raw !== 'string' || raw === 'undefined' || raw === 'null' || !isAbsolute(raw)) {
     throw new Error(
@@ -31,5 +80,5 @@ export function resolveDataDir(raw) {
       `Leave it unset to use ~/.claude-mem-lite.`
     );
   }
-  return raw;
+  return containInTests(raw);
 }

package/lib/summary-extractor.mjs

@@ -9,7 +9,7 @@
 // with empty remaining_items. This extractor runs synchronously in
 // handleStop and gives a deterministic floor.
 
-import { readFileSync, existsSync } from 'fs';
+import { readTranscriptEntries } from './transcript-scan.mjs';
 
 const EN_HEADER = /^[\s●*>-]*(Done|Not\s+done|Failed|Uncertain)\s*[:：]\s*/im;
 const ZH_HEADER = /^[\s●*>-]*(剩下的?|剩余|还剩|未完成|下次(?:要做|做|继续)?|待做|未做)\s*[:：]?\s*/m;
@@ -27,14 +27,8 @@ const ZH_KEY_IS_NOTDONE = /剩下|剩余|还剩|未完成|下次|待做|未做/;
  * @returns {string|null}
  */
 export function extractTailAssistantText(transcriptPath) {
-  if (!transcriptPath || !existsSync(transcriptPath)) return null;
-  let raw;
-  try { raw = readFileSync(transcriptPath, 'utf8'); } catch { return null; }
   let last = null;
-  for (const line of raw.split('\n')) {
-    if (!line.trim()) continue;
-    let entry;
-    try { entry = JSON.parse(line); } catch { continue; }
+  for (const entry of readTranscriptEntries(transcriptPath)) {
     if (entry.type !== 'assistant' || !entry.message) continue;
     const content = entry.message.content;
     if (!Array.isArray(content)) continue;

package/lib/transcript-scan.mjs

@@ -0,0 +1,66 @@
+// One parse of a Claude Code transcript, shared by everything that scans it.
+//
+// Audit 2026-08-22 P2-8. handleStop asked the same .jsonl the same question eight
+// different ways — tail assistant text, citations, citations again with mainOnly,
+// injected-by-surface, cite-back signals, main-thread text, cite-recall, bugfix shape —
+// and every one of them did its own readFileSync + split('\n') + JSON.parse per line.
+// Measured on a real 5.7MB transcript: ~25ms per pass, so the repeated work is roughly
+// 175ms of a 5s Stop budget, and it scales linearly with a session that runs long.
+// Parsing is nearly all of it; iterating an already-parsed array of 2908 entries is
+// 0.1ms.
+//
+// This is a memo, not a rewrite: each scanner keeps its own per-entry logic exactly as
+// it was, and only stops re-reading and re-parsing the file to get at it.
+import { readFileSync, existsSync, statSync } from 'fs';
+
+// Retention cap. Parsed entries cost ~3.45× the file size in heap (measured, same
+// transcript: 5.7MB → 19.5MB). Holding that across a whole Stop is fine for the sessions
+// people actually have; holding it for a 50MB transcript is not, and a hook that gets
+// OOM-killed loses the session's work outright. Above the cap each caller parses on its
+// own exactly as before, so the worst case is today's behaviour rather than a new one.
+export const TRANSCRIPT_CACHE_MAX_BYTES = 24 * 1024 * 1024;
+
+let cacheKey = '';
+let cacheEntries = null;
+
+/**
+ * Parsed transcript records, in file order, unparsable lines dropped.
+ *
+ * The cache key carries size and mtime: a transcript is append-only and Claude Code is
+ * still writing to it while the Stop hook runs, so a later caller in the same process
+ * must see the same fresh data it would have read for itself.
+ *
+ * @param {string|null|undefined} transcriptPath
+ * @returns {object[]} entries (empty array when the path is missing or unreadable)
+ */
+export function readTranscriptEntries(transcriptPath) {
+  if (!transcriptPath || !existsSync(transcriptPath)) return [];
+  let st;
+  try { st = statSync(transcriptPath); } catch { return []; }
+  const key = `${transcriptPath} ${st.size} ${st.mtimeMs}`;
+  if (key === cacheKey && cacheEntries) return cacheEntries;
+
+  let raw;
+  try { raw = readFileSync(transcriptPath, 'utf8'); } catch { return []; }
+  const entries = [];
+  for (const line of raw.split('\n')) {
+    if (!line.trim()) continue;
+    try { entries.push(JSON.parse(line)); } catch { /* a partially written tail line */ }
+  }
+  if (st.size <= TRANSCRIPT_CACHE_MAX_BYTES) {
+    cacheKey = key;
+    cacheEntries = entries;
+  } else {
+    // Drop whatever was held: an oversized transcript should not keep an older, smaller
+    // one alive in memory for the rest of the process either.
+    cacheKey = '';
+    cacheEntries = null;
+  }
+  return entries;
+}
+
+/** Test seam: forget the memo so a fixture rewritten within one mtime tick is re-read. */
+export function _resetTranscriptCache() {
+  cacheKey = '';
+  cacheEntries = null;
+}

package/mem-cli.mjs

@@ -17,10 +17,11 @@ import { resolveCliProject as cliProject } from './lib/cli-project.mjs';
 import { _resetVocabCache, vecTextForRow, vectorsEnabled } from './tfidf.mjs';
 import { reRankWithContext } from './search-scoring.mjs';
 import { searchObservationsHybrid } from './search-engine.mjs';
-import { fetchObsDetail, OBS_FIELDS, SESSION_DETAIL_FIELDS, supersededNotice } from './lib/get-core.mjs';
+import { fetchObsDetail, fetchPromptDetail, fetchEventDetail, OBS_FIELDS, SESSION_DETAIL_FIELDS, PROMPT_DETAIL_FIELDS, EVENT_DETAIL_FIELDS, supersededNotice } from './lib/get-core.mjs';
 import { collectBrowseTiers, getActiveMemorySessionId, BROWSE_TIERS, BROWSE_TIER_LABELS } from './lib/browse-core.mjs';
 import { deepSearch, resolveDeepMode, shouldEscalateToDeep, autoDeepLlmReady } from './deep-search.mjs';
-import { ensureRegistryDb, upsertResource, collectRegistryStats, listResourcesRanked, formatRegistryListLine } from './registry.mjs';
+import { ensureRegistryDb, collectRegistryStats, listResourcesRanked, formatRegistryListLine } from './registry.mjs';
+import { IMPORT_STRING_FIELDS, importResource, removeResource, reindexResources } from './lib/registry-core.mjs';
 import { searchResources } from './registry-retriever.mjs';
 import { computeFunnel, formatFunnel, computeSweep, formatSweep, DEFAULT_SWEEP_FLOORS, DEFAULT_SWEEP_MARGINS } from './registry-recommend.mjs';
 import { selectCompressionCandidates, groupByProjectWeek, compressGroup } from './lib/compress-core.mjs';
@@ -579,34 +580,50 @@ function renderSessionRows(db, ids) {
   return { text: parts.join('\n\n'), count: rows.length };
 }
 
+// The CLI's established labels for the prompt/event detail faces. Sharing the FIELD SET
+// with MCP (P2-6) must not rename what users already grep for, so the columns that had a
+// label keep it; anything added later falls back to title-case.
+const CLI_DETAIL_LABELS = {
+  prompt_text: 'Text',
+  content_session_id: 'Session',
+  file_paths: 'Files',
+  git_sha: 'Git',
+};
+
+/** Label a column for the CLI's `Label: value` render style. */
+const cliFieldLabel = (f) =>
+  CLI_DETAIL_LABELS[f] || f[0].toUpperCase() + f.slice(1).replace(/_/g, ' ');
+
 function renderPromptRows(db, ids) {
-  const placeholders = ids.map(() => '?').join(',');
-  const rows = db.prepare(`SELECT * FROM user_prompts WHERE id IN (${placeholders}) ORDER BY created_at_epoch ASC`).all(...ids);
+  const rows = fetchPromptDetail(db, ids);
   if (rows.length === 0) return null;
   const parts = [];
   for (const r of rows) {
     const lines = [`P#${r.id} ${fmtDateShort(r.created_at)}`];
-    if (r.prompt_text) lines.push(`Text: ${r.prompt_text}`);
-    if (r.content_session_id) lines.push(`Session: ${r.content_session_id}`);
+    // id and created_at are already in the header (same convention as the session face).
+    for (const f of PROMPT_DETAIL_FIELDS) {
+      if (f === 'id' || f === 'created_at') continue;
+      const val = r[f];
+      if (val === null || val === undefined || val === '') continue;
+      lines.push(`${cliFieldLabel(f)}: ${val}`);
+    }
     parts.push(lines.join('\n'));
   }
   return { text: parts.join('\n\n'), count: rows.length };
 }
 
 function renderEventRows(db, ids) {
-  const placeholders = ids.map(() => '?').join(',');
-  const rows = db.prepare(`SELECT * FROM events WHERE id IN (${placeholders}) ORDER BY created_at_epoch ASC`).all(...ids);
+  const rows = fetchEventDetail(db, ids);   // derives created_at from created_at_epoch
   if (rows.length === 0) return null;
   const parts = [];
   for (const r of rows) {
-    // events store the distilled lesson in `body`; only *_epoch is available for the date.
-    const lines = [`E#${r.id} [${r.event_type}] ${r.created_at_epoch ? fmtDateShort(new Date(r.created_at_epoch).toISOString()) : ''}`];
-    if (r.title) lines.push(`Title: ${r.title}`);
-    if (r.body) lines.push(`Body: ${r.body}`);
-    if (r.project) lines.push(`Project: ${r.project}`);
-    if (r.importance !== null && r.importance !== undefined) lines.push(`Importance: ${r.importance}`);
-    if (r.file_paths) lines.push(`Files: ${r.file_paths}`);
-    if (r.git_sha) lines.push(`Git: ${r.git_sha}`);
+    const lines = [`E#${r.id} [${r.event_type}] ${r.created_at ? fmtDateShort(r.created_at) : ''}`];
+    for (const f of EVENT_DETAIL_FIELDS) {
+      if (f === 'id' || f === 'event_type' || f === 'created_at') continue;   // in the header
+      const val = r[f];
+      if (val === null || val === undefined || val === '') continue;
+      lines.push(`${cliFieldLabel(f)}: ${val}`);
+    }
     parts.push(lines.join('\n'));
   }
   return { text: parts.join('\n\n'), count: rows.length };
@@ -2339,24 +2356,12 @@ function cmdRegistry(_memDb, args) {
         fail(`[mem] Invalid --source "${flags.source}". Valid: preinstalled, user, github`);
         return;
       }
-      // Preserve provenance on a metadata-only re-import: default source to 'user' only for
-      // a genuinely NEW resource. Re-importing an existing github/preinstalled row without
-      // --source must not flip it to 'user' (which also mis-grants the user-source rank boost).
-      let source = flags.source;
-      if (!source) {
-        const existing = rdb.prepare('SELECT source FROM resources WHERE type = ? AND name = ?').get(resourceType, name);
-        source = existing ? existing.source : 'user';
-      }
-      const fields = { name, type: resourceType, status: 'active', source };
-      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);
-        fields[camel] = flags[f] || '';
-      }
-      const id = upsertResource(rdb, fields);
-      // User-imported resources get 'installed' quality tier (user explicitly chose to add them)
-      if (id && !flags.source) {
-        rdb.prepare("UPDATE resources SET quality_tier = 'installed' WHERE id = ?").run(id);
-      }
+      // Provenance preservation + the 'installed' tier grant live in lib/registry-core.mjs,
+      // shared with the mem_registry MCP twin (audit 2026-08-22 P1-3). CLI flags are
+      // kebab-case; the core's field list is the canonical snake_case source.
+      const fields = {};
+      for (const f of IMPORT_STRING_FIELDS) fields[f] = flags[f.replace(/_/g, '-')] || '';
+      const { id } = importResource(rdb, { name, type: resourceType, source: flags.source, fields });
       out(`[mem] Imported: ${resourceType}:${name} (id=${id})`);
       if (!flags['capability-summary'] && !flags['use-cases']) {
         out('[mem] Tip: Add --capability-summary or --use-cases so the resource appears in searches.');
@@ -2371,17 +2376,16 @@ function cmdRegistry(_memDb, args) {
       const name = flags.name;
       const resourceType = flags['resource-type'];
       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
+      const { removed } = removeResource(rdb, { name, type: resourceType });
+      out(removed
         ? `[mem] Removed: ${resourceType}:${name}`
         : `[mem] Not found: ${resourceType}:${name}`);
       return;
     }
 
     if (action === 'reindex') {
-      rdb.exec("INSERT INTO resources_fts(resources_fts) VALUES('rebuild')");
-      const count = rdb.prepare('SELECT COUNT(*) as c FROM resources WHERE status = ?').get('active');
-      out(`[mem] FTS5 reindexed. ${count.c} active resources.`);
+      const { activeCount } = reindexResources(rdb);
+      out(`[mem] FTS5 reindexed. ${activeCount} active resources.`);
       return;
     }
   } finally {