claude-mem-lite 6.7.0 → 6.7.2

package/.claude-plugin/marketplace.json

@@ -9,7 +9,7 @@
   "plugins": [
     {
       "name": "claude-mem-lite",
-      "version": "6.7.0",
+      "version": "6.7.2",
       "source": "./",
       "homepage": "https://github.com/sdsrss/claude-mem-lite",
       "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": "6.7.0",
+  "version": "6.7.2",
   "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/hook-context.mjs

@@ -580,7 +580,8 @@ export function buildSessionContextLines(
     SELECT o.id, o.type, o.title, o.lesson_learned, o.files_modified FROM observations o
     WHERE o.project = ? AND ${liveObsFilterSql('o')}
       AND COALESCE(o.importance, 1) >= 2
-    ORDER BY o.created_at_epoch DESC LIMIT ${KEY_CONTEXT_LIMIT}
+      AND ${notLowSignalTitleClause('o')}
+    ORDER BY o.created_at_epoch DESC, o.id DESC LIMIT ${KEY_CONTEXT_LIMIT}
   `,
     )
     .all(project);

package/lib/file-edge-match.mjs

@@ -105,6 +105,134 @@ export function jsonArrayLikeNeedle(s) {
   return likeLiteral(JSON.stringify(String(s ?? '')).slice(1, -1));
 }
 
+/**
+ * How much a token LOOKS like a file path, from its shape alone. Higher wins.
+ *
+ * Only ever used to ORDER candidates, never to drop one — see rankFileCandidates.
+ * Every term below is a character-class property of the token, not a list of
+ * known-bad spellings: a blacklist is what the next unusual version string walks
+ * around, and this repo has thrown three hand-drawn classes away already.
+ */
+function fileShapeScore(token) {
+  const raw = String(token ?? '');
+  const name = basenameAnySep(raw);
+  const dot = name.lastIndexOf('.');
+  // `dot === 0` is a DOTFILE (`.env`, `.gitignore`, `.npmrc`), not an
+  // extensionless token — score `env` as the extension. The first cut rejected
+  // it with `dot <= 0`, which scored every dotfile 0, i.e. BELOW the version
+  // numbers this function exists to demote. Not theoretical: `extractFiles`
+  // emits `src/.env`, and six version tokens then evicted it from a window the
+  // pre-ranking code reached (pre-ship review, 2026-09-11).
+  if (dot < 0 || dot === name.length - 1) return 0;
+  const ext = name.slice(dot + 1);
+  let score = 0;
+  // A real extension starts with a LETTER. Version numbers ('v4.0.1' -> '1'),
+  // decimals and timestamp fragments ('…39.602Z' -> '602Z') do not — and those
+  // three are what `extractFiles`' regex actually emits on this corpus.
+  if (/^[A-Za-z]/.test(ext)) score += 2;
+  // Real extensions are short. A member expression borrows the letter-initial
+  // shape but not the length ('JSON.stringify', 'e.target_id').
+  if (ext.length <= 5) score += 1;
+  // A separator is the strongest evidence available without touching disk.
+  // Ask the token, and strip TRAILING separators first: comparing against the
+  // basename says yes for `foo.mjs/` too, because basenameAnySep strips those,
+  // so a token with no internal separator collected the bonus.
+  if (/[/\\]/.test(raw.replace(/[/\\]+$/, ''))) score += 2;
+  return score;
+}
+
+/**
+ * Order file candidates most-path-like first and drop exact repeats, for the
+ * callers that can only afford to probe the first few.
+ *
+ * `searchByFile` runs one prepared-statement execution per candidate on the
+ * UserPromptSubmit hot path, so it caps at FILE_PROBE_CAP — and it used to take
+ * the ones `extractFiles` happened to match FIRST, which is text order.
+ *
+ * Measured in one run over 216 live user_prompts (2026-09-11), denominator = the
+ * 50 prompts naming at least one file the corpus can reach, each lever isolated
+ * at the cap that ships:
+ *
+ *                                 all reachable lost   >=1 lost
+ *   text order, cap 3 (pre-fix)     14 (28.0%)          34 (68.0%)
+ *   text order, cap 6                7 (14.0%)          30 (60.0%)
+ *   ranked,     cap 6 (shipped)      2 ( 4.0%)          25 (50.0%)
+ *
+ * Neither lever alone gets there, and at cap 6 the ORDERING is the larger of
+ * the two. An earlier revision quoted "ranking alone 28.0% -> 24.0%", which was
+ * measured at cap 3 with a scorer that ranked dotfiles last: the wrong ablation
+ * on a window too small for ordering to matter.
+ *
+ * Oracle: a candidate counts as reachable when its basename matches one in
+ * `observation_files`. That is a strict SUPERSET of what the shipped query can
+ * return — it ignores the project, lookback, importance and low-signal
+ * predicates — measured at 26 of 152 candidates over-counted, with no false
+ * negatives (pre-ship review). Applied identically to every arm, so the
+ * direction holds; the exact percentages are not properties of the shipped
+ * query, and "flat beyond 6" is true of this oracle only (under the strict one
+ * the reviewer measured, the curve drops again at 10).
+ *
+ * The noise was never buying precision either: only 1 prompt reached
+ * `hasExplicitSignal` via extractFiles alone — that figure is from the audit's
+ * separate 533-prompt transcript corpus, NOT from the 216 rows above.
+ *
+ * SORT, not filter, and that is the safety property — with one caveat the
+ * caller owns: downstream of a `.slice(cap)` a position IS a candidate, so a
+ * wrong score can still evict. That is why fileShapeScore leans on structural
+ * properties and never on a list of known-bad spellings.
+ *
+ * Dedup folds ASCII A-Z ONLY, because that is the alphabet the SQL folds:
+ * SQLite's `COLLATE NOCASE` and `LIKE` are ASCII-case-insensitive (this file's
+ * own header, arm 1/2). JS `toLowerCase()` folds the whole Unicode table, so it
+ * collapsed `Ä.mjs` and `ä.mjs` into one probe while SQLite returns distinct
+ * rows for each — a DROP, which this function contractually never does.
+ * Unreachable through today's only caller (`extractFiles`' class is `[\w./-]`
+ * and `\w` is ASCII without the `u` flag), fixed because the exported contract
+ * is what the next caller reads.
+ *
+ * The index tiebreak keeps text order inside a tier explicitly rather than
+ * leaning on sort stability.
+ */
+export function rankFileCandidates(files) {
+  // A non-array would be iterated by character (`'a.mjs'` -> five candidates)
+  // or throw. One caller exists and it passes an array; fail closed for the next.
+  if (!Array.isArray(files)) return [];
+  const seen = new Set();
+  const uniq = [];
+  for (const f of files) {
+    const s = String(f ?? '');
+    if (!s) continue;
+    const key = s.replace(/[A-Z]/g, (c) => c.toLowerCase());
+    if (seen.has(key)) continue;
+    seen.add(key);
+    uniq.push(s);
+  }
+  return uniq
+    .map((f, i) => ({ f, i, score: fileShapeScore(f) }))
+    .sort((a, b) => b.score - a.score || a.i - b.i)
+    .map((x) => x.f);
+}
+
+/**
+ * The path a tool-use touched, whichever key the tool spells it with.
+ *
+ * `Edit` / `Write` / `Read` carry `file_path`; `NotebookEdit` carries
+ * `notebook_path` and NEVER `file_path`. That one rule had three separate
+ * spellings in this repo (an inline `??` in each recall script, a regex
+ * alternation in lib/hook-stdin.mjs) and a FOURTH site that simply did not know
+ * it — lib/import-jsonl.mjs gated its file edges on `file_path` alone, so every
+ * imported notebook edit built no (obs,file) edge at all and was unreachable
+ * through the recall path this module exists to serve. A second copy is exactly
+ * what produced R12 B-1; this is the home.
+ *
+ * @param {object|null|undefined} input a tool-use `input` / `tool_input` object
+ * @returns {string|undefined} the path, or undefined when the shape carries none
+ */
+export function toolEditPath(input) {
+  if (!input || typeof input !== 'object') return undefined;
+  return input.file_path ?? input.notebook_path;
+}
+
 /** Bind values for fileMatchClause, in placeholder order. */
 export function fileMatchParams(filePath) {
   const fname = basenameAnySep(filePath);

package/lib/import-jsonl.mjs

@@ -18,6 +18,8 @@ import { readFileSync, statSync } from 'fs';
 import { createHash } from 'crypto';
 import { scrubSecrets } from '../secret-scrub.mjs';
 import { scrubRecord } from './scrub-record.mjs';
+import { toolEditPath } from './file-edge-match.mjs';
+import { insertObservationFiles } from './observation-write.mjs';
 
 const TOOL_TO_TYPE = {
   Edit: 'change',
@@ -130,11 +132,16 @@ function importToolPair(db, toolUse, toolResult, project) {
       ? toolResult.content
       : JSON.stringify(toolResult?.content ?? '').slice(0, 4000);
 
+  // D#35: this gated on `input.file_path` alone, and `NotebookEdit` carries
+  // `notebook_path` and never `file_path` — so the branch named NotebookEdit
+  // while being unable to fire for it, and every imported notebook edit built
+  // no (obs,file) edge. `toolEditPath` is the single home for that rule.
+  const editedPath = toolEditPath(toolUse.input);
   const filesModified =
-    (toolName === 'Edit' || toolName === 'Write' || toolName === 'NotebookEdit') && toolUse.input?.file_path
-      ? [toolUse.input.file_path]
+    (toolName === 'Edit' || toolName === 'Write' || toolName === 'NotebookEdit') && editedPath
+      ? [editedPath]
       : [];
-  const filesRead = toolName === 'Read' && toolUse.input?.file_path ? [toolUse.input.file_path] : [];
+  const filesRead = toolName === 'Read' && editedPath ? [editedPath] : [];
 
   // `narrative` carries the body and `text` is the derived search blob
   // (lib/observation-write.mjs rebuildObservationDerived). Writing the payload to `text`
@@ -144,7 +151,18 @@ function importToolPair(db, toolUse, toolResult, project) {
   // write directly.
   const body = `${inputJson}\n---\n${resultText}`;
   const safe = scrubRecord('observations', {
-    title: `${toolName}: ${(toolUse.input?.command || toolUse.input?.file_path || '').slice(0, 80)}`,
+    // This string IS the cross-run dedup key: tryImportToolPair synthesizes it
+    // byte-for-byte from the same expression to decide whether a row was already
+    // imported, so the two sites must be widened TOGETHER or every import
+    // duplicates. An earlier cut of this round kept the title on `file_path`
+    // alone to avoid the migration — and shipped `NotebookEdit: ` with an empty
+    // label for exactly the rows D#35 had just made reachable. Pre-ship review:
+    // "the surface the round unblocked renders a row that identifies nothing."
+    //
+    // The cost is real and bounded: NotebookEdit rows imported before v6.7.2
+    // carry the old key, so the next import re-adds each of them ONCE and then
+    // matches forever. Stated in the CHANGELOG rather than absorbed silently.
+    title: `${toolName}: ${(toolUse.input?.command || toolEditPath(toolUse.input) || '').slice(0, 80)}`,
     subtitle: '',
     text: body,
     narrative: body,
@@ -154,28 +172,49 @@ function importToolPair(db, toolUse, toolResult, project) {
     search_aliases: null,
   });
 
-  db.prepare(
-    `
+  const inserted = db
+    .prepare(
+      `
     INSERT INTO observations
       (memory_session_id, project, text, type, title, subtitle, narrative, concepts, facts, files_read, files_modified, importance, created_at, created_at_epoch)
     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
   `,
-  ).run(
-    memId(sessionId),
-    project,
-    safe.text,
-    type,
-    safe.title,
-    safe.subtitle,
-    safe.narrative,
-    safe.concepts,
-    safe.facts,
-    JSON.stringify(filesRead),
-    JSON.stringify(filesModified),
-    1,
-    ts,
-    Date.parse(ts) || Date.now(),
-  );
+    )
+    .run(
+      memId(sessionId),
+      project,
+      safe.text,
+      type,
+      safe.title,
+      safe.subtitle,
+      safe.narrative,
+      safe.concepts,
+      safe.facts,
+      JSON.stringify(filesRead),
+      JSON.stringify(filesModified),
+      1,
+      ts,
+      Date.parse(ts) || Date.now(),
+    );
+
+  // Import wrote `files_modified` as a JSON column and stopped there, so no
+  // imported observation had a row in the `observation_files` junction — and
+  // that junction is what the file-recall paths JOIN. Two of them can now return
+  // an imported row: `recallByFile` (CLI `recall` + `mem_recall`) and
+  // `searchByFile` (the UserPromptSubmit leg). The pre-tool recall leg JOINs it
+  // too but still CANNOT — pre-ship review measured three independent structural
+  // gates, two of them literals: `importance >= 2` against the `1` written
+  // below, and `lesson_learned` non-empty OR `type IN ('bugfix','decision')`
+  // against a NULL lesson and a type that is only ever `change`/`discovery`.
+  // Do not list it as a beneficiary without changing one of those.
+  //
+  // Measured before the fix: an
+  // `Edit` with `file_path` set produced `files_modified=["/repo/alpha.mjs"]`
+  // and ZERO junction rows, so the defect was never NotebookEdit-specific —
+  // D#35 named a symptom of it. Same call and same list as the canonical save
+  // path (lib/save-observation.mjs:324), which is why `insertObs` in the test
+  // helpers mirrors it and no existing test could see the gap.
+  insertObservationFiles(db, Number(inserted.lastInsertRowid), filesModified);
   return true;
 }
 
@@ -256,7 +295,7 @@ export async function importJsonl(db, path, { project }) {
     // Cross-call dedup: synthesize the title the previous run would have
     // written and check the seenObs set seeded from the DB.
     const toolName = useEv.name || 'unknown';
-    const titlePreview = `${toolName}: ${(useEv.input?.command || useEv.input?.file_path || '').slice(0, 80)}`;
+    const titlePreview = `${toolName}: ${(useEv.input?.command || toolEditPath(useEv.input) || '').slice(0, 80)}`;
     const ts = useEv.timestamp || new Date().toISOString();
     // Match the storage convention from importToolPair (memId-prefixed) so
     // the seenObs entries seeded from the DB can be matched on a re-run.

package/lib/recall-core.mjs

@@ -42,7 +42,7 @@ export function recallByFile(db, file, { limit = 10, includeNoise = false } = {}
     WHERE ${liveObsFilterSql('o')}
       AND ${fileMatchClause('of2')}
       ${noiseClause}
-    ORDER BY o.created_at_epoch DESC
+    ORDER BY o.importance DESC, o.created_at_epoch DESC, o.id DESC
     LIMIT ?
   `,
     )

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "claude-mem-lite",
-  "version": "6.7.0",
+  "version": "6.7.2",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "claude-mem-lite",
-      "version": "6.7.0",
+      "version": "6.7.2",
       "os": [
         "darwin",
         "linux",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "6.7.0",
+  "version": "6.7.2",
   "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/post-tool-recall.js

@@ -30,6 +30,7 @@ import { queueHookContext, flushHookStdout } from '../lib/hook-stdout.mjs';
 // P1-9: one bounded stdin reader. Import-free, like hook-stdout.mjs beside it.
 import { readHookStdin, TOOL_INPUT_FILE_MAX_BYTES } from '../lib/hook-stdin.mjs';
 import { cooldownPathFor as sharedCooldownPathFor } from '../lib/cooldown-path.mjs';
+import { toolEditPath } from '../lib/file-edge-match.mjs';
 
 const SALIENCE_BIND = process.env.CLAUDE_MEM_SALIENCE === 'bind';
 
@@ -59,7 +60,7 @@ async function main() {
     // v6.7.0 and this leg did not, which is the repo's most repeated failure shape:
     // a fix that closes ONE of the inputs reaching the same line. Caught in pre-ship
     // review of that very round.
-    filePath = e.tool_input?.file_path ?? e.tool_input?.notebook_path;
+    filePath = toolEditPath(e.tool_input);
     sessionId = e.session_id || null;
   } catch {
     return;

package/scripts/pre-tool-recall.js

@@ -25,6 +25,7 @@ import {
   fileMatchParams,
   basenameAnySep,
   jsonArrayLikeNeedle,
+  toolEditPath,
 } from '../lib/file-edge-match.mjs';
 import { fileIntelFor } from '../lib/file-intel.mjs';
 import { shouldWarnReread, buildRereadWarning, readFileMeta } from '../lib/reread-guard.mjs';
@@ -406,7 +407,7 @@ try {
     // additionalProperties:false. Reading only `file_path` made this hook a
     // no-op on every .ipynb edit (R12 audit, partition B-2). utils.mjs's
     // `case 'NotebookEdit'` already knew the shape differs; this leg did not.
-    filePath = event.tool_input?.file_path ?? event.tool_input?.notebook_path;
+    filePath = toolEditPath(event.tool_input);
     sessionId = event.session_id || null;
     toolName = event.tool_name || null;
     const off = event.tool_input?.offset;

package/scripts/user-prompt-search.js

@@ -18,7 +18,12 @@ import {
 import { readHookStdin } from '../lib/hook-stdin.mjs';
 import { resolveRuntimeDir } from '../lib/resolve-data-dir.mjs';
 import { liveObsFilterSql, injectionRelevanceSql } from '../lib/inject-search-core.mjs';
-import { fileMatchClause, fileMatchParams, basenameAnySep } from '../lib/file-edge-match.mjs';
+import {
+  fileMatchClause,
+  fileMatchParams,
+  basenameAnySep,
+  rankFileCandidates,
+} from '../lib/file-edge-match.mjs';
 import { cjkPrecisionOk } from '../nlp.mjs';
 import { upsFtsQuery } from '../lib/ups-query.mjs';
 import { corpusFloorScale } from '../lib/relevance-floor.mjs';
@@ -465,6 +470,41 @@ export function searchByFts(
   return { rows, mode };
 }
 
+/**
+ * How many candidates the file leg probes, one prepared-statement execution each.
+ *
+ * Was 3, chosen when the leg was written and never measured.
+ *
+ * R12 B-4 named both halves of the mechanism in its own title —
+ * `files.slice(0, 3)` AND `extractFiles` text order — but its prescribed REMEDY
+ * is ordering only, and ordering alone does not get there. Measured over 216
+ * live user_prompts (2026-09-11), denominator 50 (prompts naming >=1 reachable
+ * file), all-reachable-lost, one run, each lever isolated:
+ *
+ *   text order, cap 3 (pre-fix)  28.0%    text order, cap 6  14.0%
+ *   ranked,     cap 6 (shipped)   4.0%
+ *
+ * Decomposing the residue at cap 3 showed why ordering alone stalls: all 12
+ * still-harmed prompts were blocked by other file-SHAPED candidates and NONE by
+ * noise, and the 50-prompt denominator names a median of 3 distinct reachable
+ * files (mean 3.04) — more than the window held. Sweeping the cap, ranked arm:
+ *
+ *   cap  3 -> 28.0%   4 -> 20.0%   5 -> 6.0%   6 -> 4.0%   8/10/12 -> 4.0%
+ *
+ * Six is the knee under this oracle (see rankFileCandidates for what the oracle
+ * over-counts, and why flatness past 6 is oracle-dependent). The residual two
+ * prompts name their shallowest reachable candidate 23 and 13 deep.
+ *
+ * Cost is linear in probes, and the ceiling is not the expectation: only 20.0%
+ * of candidate-bearing prompts have more than 3 unique candidates, so the mean
+ * is 0.56 extra probes per UserPromptSubmit (~31µs), against a ceiling of 3
+ * (+0.156ms measured on the live 41-observation store). On a synthetic
+ * 3747-observation store per-probe cost ranged 50-489µs, so the worst case is
+ * ~+1.5ms; that spread is an artifact of how the fixture was generated and is
+ * quoted as a bound, not as a property of any real corpus.
+ */
+const FILE_PROBE_CAP = 6;
+
 function searchByFile(db, files, project, limit) {
   if (files.length === 0) return [];
 
@@ -484,11 +524,16 @@ function searchByFile(db, files, project, limit) {
       AND o.created_at_epoch > ?
       AND ${fileMatchClause('of2')}
       AND ${notLowSignalTitleClause('o')}
-    ORDER BY o.created_at_epoch DESC
+    ORDER BY o.importance DESC, o.created_at_epoch DESC, o.id DESC
     LIMIT ?
   `);
 
-  for (const file of files.slice(0, 3)) {
+  // Rank before capping (R12 B-4). `files` arrives in the order `extractFiles`
+  // matched it, which is TEXT order — so three version tokens ahead of the file
+  // the prompt is about evicted it from this window entirely. rankFileCandidates
+  // reorders and de-duplicates; it never drops, so the cap still sees every
+  // candidate it used to, just best-first.
+  for (const file of rankFileCandidates(files).slice(0, FILE_PROBE_CAP)) {
     // Shared predicate (pre-tag review of v3.76.2, SF-1/S2). This leg used
     // `file.split('/').pop()` — weaker than node:path `basename`, since it misses '\'
     // even ON a Windows host — plus a bare `%<basename>` suffix LIKE with no path