claude-mem-lite 6.7.0 → 6.7.1

package/.claude-plugin/marketplace.json

@@ -9,7 +9,7 @@
   "plugins": [
     {
       "name": "claude-mem-lite",
-      "version": "6.7.0",
+      "version": "6.7.1",
       "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.1",
   "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,114 @@ 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);
+}
+
 /** Bind values for fileMatchClause, in placeholder order. */
 export function fileMatchParams(filePath) {
   const fname = basenameAnySep(filePath);

package/npm-shrinkwrap.json

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

package/package.json

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