claude-mem-lite 3.35.2 → 3.37.0

package/registry-recommend.mjs

@@ -18,8 +18,12 @@ export function getRecommendMode() {
 
 // Provisional gate thresholds — calibrated from shadow data before Phase 2 (spec §8).
 // relevance is raw bm25 (negative; more negative = better). Candidate must clear |floor|.
-export const RECO_BM25_FLOOR = -1.5;     // require row.relevance <= -1.5
-export const RECO_MARGIN = 0.5;          // require candidates[1].relevance - candidates[0].relevance >= 0.5
+export const RECO_BM25_FLOOR = -1.5;     // floor stays on raw bm25 (absolute topical relevance)
+// Margin is measured in COMPOSITE space (the metric that orders + selects the winner), NOT raw
+// bm25 — see applyGate. composite = bm25*0.4 - priors, so the scale is ~0.4x raw; 0.5 raw ≈ 0.2
+// composite is the principled starting point. Final value comes from `recommend-stats --sweep`
+// after dogfood (D#47); DEFAULT_SWEEP_MARGINS is likewise on the composite scale.
+export const RECO_MARGIN = 0.2;          // require candidates[1].composite_score - candidates[0].composite_score >= this
 const RECO_COOLDOWN_MS = 300_000;        // 5 min, mirrors T4 SKILL_COOLDOWN_MS (internal)
 
 // Lazy runtime-path resolution: read CLAUDE_MEM_DIR at call time (mirrors schema.mjs:13
@@ -35,9 +39,14 @@ const TOKEN_SPLIT = /[^a-z0-9一-鿿]+/;
 export function fetchInstalledSkillCandidates(rdb, promptText, limit = 10) {
   if (!rdb || !promptText) return [];
   let rows;
-  try { rows = searchResources(rdb, promptText, { type: 'skill', limit }); }
+  // Over-fetch, THEN filter to installed. quality_tier='installed' is a post-SQL JS filter, so a
+  // plain LIMIT starves installed skills that rank below other-tier matches: a weak installed
+  // match sitting past the top-N is sliced off → the gate sees no candidate → spurious
+  // no_candidate BLOCK (the −0.15 installed composite bonus is negligible vs the bm25 spread).
+  // A wide headroom lets the composite-best installed skill actually survive to the gate.
+  try { rows = searchResources(rdb, promptText, { type: 'skill', limit: Math.max(limit * 5, 50) }); }
   catch { return []; }
-  return rows.filter(r => r.quality_tier === 'installed');
+  return rows.filter(r => r.quality_tier === 'installed').slice(0, limit);
 }
 
 /**
@@ -65,7 +74,13 @@ export function applyGate(candidates, promptText, cooldownSet) {
   const top = candidates[0];
   if (!(top.relevance <= RECO_BM25_FLOOR)) return { verdict: 'BLOCK', reason: 'below_floor', candidate: top };
   if (candidates.length >= 2) {
-    const margin = candidates[1].relevance - top.relevance; // positive when top is clearly better
+    // Separation measured in the SAME metric that ordered the candidates (composite_score),
+    // NOT relevance. candidates arrive composite ASC so `top` IS the composite winner; a raw
+    // relevance margin let a composite-promoted top sit BELOW candidates[1] in relevance →
+    // negative margin → spurious low_margin BLOCK (and a permanent dead-zone in the ROC sweep).
+    // composite2 - composite1 is >= 0 by sort order. The floor above stays on raw bm25 — the
+    // absolute-relevance gate that stops a popular-but-irrelevant composite promotion.
+    const margin = candidates[1].composite_score - top.composite_score;
     if (!(margin >= RECO_MARGIN)) return { verdict: 'BLOCK', reason: 'low_margin', candidate: top };
   }
   if (!intentMatch(promptText, top)) return { verdict: 'BLOCK', reason: 'intent_mismatch', candidate: top };
@@ -192,11 +207,13 @@ export function computeFunnel(days = 7) {
   return stats;
 }
 
-// Default sweep grid (B3). Raw BM25 magnitudes for real matches run ≈ -10..-15, so the
-// shipped floor (-1.5) is far more permissive than it looks; the grid spans that real range
-// so the ROC curve actually moves. Override via `recommend-stats --sweep --floors a,b --margins x,y`.
+// Default sweep grid (B3). FLOORS are raw bm25 (real matches run ≈ -10..-15, so the shipped
+// -1.5 floor is far more permissive than it looks; the grid spans that real range). MARGINS are
+// on the COMPOSITE scale (composite = bm25*0.4 - priors), matching replayGate's margin metric —
+// the old raw-bm25 grid [0,0.5,1,2,4] was ~2.5x too wide for composite separations.
+// Override via `recommend-stats --sweep --floors a,b --margins x,y`.
 export const DEFAULT_SWEEP_FLOORS = [-1.5, -5, -8, -10, -12];
-export const DEFAULT_SWEEP_MARGINS = [0, 0.5, 1, 2, 4];
+export const DEFAULT_SWEEP_MARGINS = [0, 0.05, 0.1, 0.2, 0.4];
 
 /**
  * Recompute the gate verdict for a logged reco row at a hypothetical (floor, margin),
@@ -207,7 +224,15 @@ export function replayGate(row, floor, margin) {
   const r1 = row.relevance;
   // null/undefined relevance coerces to 0/NaN, so `r1 <= floor` is false → BLOCK (no null check).
   if (!(r1 <= floor)) return 'BLOCK';
-  if (Number.isFinite(row.rel2) && !((row.rel2 - r1) >= margin)) return 'BLOCK';
+  // Margin on composite when the row logged it (post-switch rows), matching the live applyGate
+  // metric; fall back to the legacy relevance margin for rows written before composite1/composite2
+  // existed (they age out of the 7d sweep window). Single-candidate rows (no rel2/composite2) skip
+  // the margin gate either way. NOTE: sweep `margin` is on the COMPOSITE scale for new rows.
+  if (Number.isFinite(row.composite1) && Number.isFinite(row.composite2)) {
+    if (!((row.composite2 - row.composite1) >= margin)) return 'BLOCK';
+  } else if (Number.isFinite(row.rel2)) {
+    if (!((row.rel2 - r1) >= margin)) return 'BLOCK';
+  }
   if (!row.intentTop) return 'BLOCK';
   if (row.cooldownTop) return 'BLOCK';
   return 'PASS';
@@ -230,11 +255,25 @@ export function computeSweep(days = 7, floors = DEFAULT_SWEEP_FLOORS, margins =
   }
   const grid = [];
   for (const floor of floors) for (const margin of margins) {
-    let pass = 0, matchPass = 0, matchAdopt = 0;
+    let pass = 0;
+    // Matched precision MUST dedup (session, skill) exactly like computeFunnel (mPass/mAdopt
+    // via per-session Sets). Counting raw reco rows here inflated matchPass by every repeat
+    // recommendation of the same skill in one session, so the sweep's precision silently
+    // disagreed with the funnel headline and was biased toward frequently-recommended skills —
+    // corrupting the exact (floor,margin) signal the sweep exists to inform. `pass` stays a raw
+    // volume count (it is not a precision denominator).
+    const passBySession = new Map(); // session -> Set<skillLower> that PASSED at this cell
     for (const r of recos) {
       if (replayGate(r, floor, margin) !== 'PASS') continue;
       pass++;
-      if (r.session) { matchPass++; if (adoptBySession.get(r.session)?.has(lc(r.skill))) matchAdopt++; }
+      if (!r.session) continue;
+      if (!passBySession.has(r.session)) passBySession.set(r.session, new Set());
+      passBySession.get(r.session).add(lc(r.skill));
+    }
+    let matchPass = 0, matchAdopt = 0;
+    for (const [session, skills] of passBySession) {
+      const adopted = adoptBySession.get(session);
+      for (const sk of skills) { matchPass++; if (adopted?.has(sk)) matchAdopt++; }
     }
     grid.push({ floor, margin, pass, matchPass, matchAdopt, precision: matchPass ? matchAdopt / matchPass : null });
   }
@@ -265,8 +304,10 @@ export function recommendSkill(rdb, promptText, project, opts = {}) {
     // NOT the registry short name ('superpowers-tdd') — adoption rows log toolInput.skill (the slug),
     // so logging top.name made in-session matched precision a guaranteed 0 for every namespaced skill.
     skill: top ? (top.invocation_name || top.name) : null,
-    relevance: top ? top.relevance : null,
-    rel2: candidates[1] ? candidates[1].relevance : null,
+    relevance: top ? top.relevance : null,                    // floor replay (absolute bm25)
+    rel2: candidates[1] ? candidates[1].relevance : null,     // legacy margin replay (pre-composite rows)
+    composite1: top ? top.composite_score : null,             // margin replay (composite — the live gate metric)
+    composite2: candidates[1] ? candidates[1].composite_score : null,
     intentTop: top ? intentMatch(promptText, top) : false,
     cooldownTop: top ? cooldownSet.has(String(top.name).toLowerCase()) : false,
     ncand: candidates.length,

package/registry.mjs

@@ -62,8 +62,9 @@ const RESOURCES_SCHEMA = `
 `;
 
 // Canonical FTS5 column order — all consumers must use this order.
-// BM25 weights (positional): trigger_patterns(5), keywords(3), capability_summary(3),
+// BM25 weights (positional): trigger_patterns(3), keywords(3), capability_summary(3),
 //   intent_tags(2), use_cases(2), domain_tags(1), tech_stack(1), name(1)
+//   — must match the bm25(resources_fts, 3,3,3,2,2,1,1,1) call in COMPOSITE_EXPR.
 const FTS5_SCHEMA = `
   CREATE VIRTUAL TABLE IF NOT EXISTS resources_fts USING fts5(
     trigger_patterns,
@@ -371,12 +372,23 @@ const UPSERT_SQL = `
     repo_stars=CASE WHEN excluded.repo_stars > 0 THEN excluded.repo_stars ELSE repo_stars END,
     local_path=excluded.local_path, file_hash=excluded.file_hash,
     invocation_name=CASE WHEN excluded.invocation_name != '' THEN excluded.invocation_name ELSE invocation_name END,
-    intent_tags=excluded.intent_tags, domain_tags=excluded.domain_tags,
-    action_type=excluded.action_type, trigger_patterns=excluded.trigger_patterns,
-    capability_summary=excluded.capability_summary, input_type=excluded.input_type,
-    output_type=excluded.output_type, prerequisites=excluded.prerequisites,
-    keywords=excluded.keywords, tech_stack=excluded.tech_stack,
-    use_cases=excluded.use_cases, complexity=excluded.complexity,
+    -- Preserve-on-empty (mirror repo_stars/invocation_name above): a PARTIAL re-upsert --
+    -- e.g. "registry import --name X --capability-summary ...", where mem-cli defaults every
+    -- other flag to '' -- must NOT blank the FTS text columns and silently drop the resource
+    -- out of search (import is the ONLY registry edit path; there is no update subcommand).
+    -- Full upserts are unaffected: every field is non-empty, so the CASE picks excluded.
+    intent_tags=CASE WHEN excluded.intent_tags != '' THEN excluded.intent_tags ELSE intent_tags END,
+    domain_tags=CASE WHEN excluded.domain_tags != '' THEN excluded.domain_tags ELSE domain_tags END,
+    action_type=CASE WHEN excluded.action_type != '' THEN excluded.action_type ELSE action_type END,
+    trigger_patterns=CASE WHEN excluded.trigger_patterns != '' THEN excluded.trigger_patterns ELSE trigger_patterns END,
+    capability_summary=CASE WHEN excluded.capability_summary != '' THEN excluded.capability_summary ELSE capability_summary END,
+    input_type=CASE WHEN excluded.input_type != '' THEN excluded.input_type ELSE input_type END,
+    output_type=CASE WHEN excluded.output_type != '' THEN excluded.output_type ELSE output_type END,
+    prerequisites=excluded.prerequisites,
+    keywords=CASE WHEN excluded.keywords != '' THEN excluded.keywords ELSE keywords END,
+    tech_stack=CASE WHEN excluded.tech_stack != '' THEN excluded.tech_stack ELSE tech_stack END,
+    use_cases=CASE WHEN excluded.use_cases != '' THEN excluded.use_cases ELSE use_cases END,
+    complexity=excluded.complexity,
     indexed_at=excluded.indexed_at, updated_at=datetime('now')
 `;
 

package/schema.mjs

@@ -89,7 +89,16 @@ export const CODE_DIR = join(homedir(), '.claude-mem-lite');
 // failure leaves the marker unset and retries on the next open. New TABLE via
 // CORE_SCHEMA on the forced pass; LATEST_MIGRATION_COLUMN unchanged (no new
 // column) — same pattern as v35/v36/v38.
-export const CURRENT_SCHEMA_VERSION = 39;
+// v40 (round-5 audit HIGH): forces one migration pass so the now column-aware ensureFTS
+// widens any STALE FTS table on existing DBs. Early-adopter stores created before a column
+// was added to an FTS list (session_summaries_fts predates `remaining_items`, v2.2.0) carried
+// a narrow FTS table forever — the old ensureFTS only created a table when absent, never
+// widened it — while its triggers were rebuilt with the current wider column list, so every
+// session_summaries UPDATE threw "no column named remaining_items" and was silently swallowed
+// (Haiku summary enrichment lost every session). Pure index reheal (no data migration, no
+// column drop); idempotent. New behavior via the forced pass; LATEST_MIGRATION_COLUMN
+// unchanged (no new column) — same pattern as v35/v36/v38/v39.
+export const CURRENT_SCHEMA_VERSION = 40;
 
 // Sentinel column for the LATEST migration set. The fast-path uses this to
 // self-heal half-migrated DBs — schema_version bumped but column ALTERs rolled
@@ -816,7 +825,14 @@ const DEFERRED_CLEANUPS = [
             }
           }
           if (canonical) {
-            for (const table of ['observations', 'sdk_sessions', 'session_summaries']) {
+            // Rename the short project to canonical on EVERY project-scoped table.
+            // Originally only the first three were rewritten, so a short-named
+            // project's deferred TODOs (deferred_work), activity (events), citation
+            // history (citation_log), and /clear-/exit handoffs (session_handoffs)
+            // were stranded on the old name — invisible to every project-scoped query
+            // after normalization. All seven carry a `project` column (verified).
+            for (const table of ['observations', 'sdk_sessions', 'session_summaries',
+                                 'session_handoffs', 'citation_log', 'events', 'deferred_work']) {
               db.prepare(`UPDATE ${table} SET project = ? WHERE project = ?`).run(canonical.project, shortName);
             }
           }
@@ -974,8 +990,32 @@ export function ensureFTS(db, ftsName, tableName, columns) {
   const newVals = columns.map(c => `new.${c}`).join(', ');
   const oldVals = columns.map(c => `old.${c}`).join(', ');
 
-  const ftsExists = db.prepare(`SELECT 1 FROM sqlite_master WHERE type='table' AND name=?`).get(ftsName);
-  if (!ftsExists) {
+  // Column-aware (re)creation. An existing FTS table is never silently reused when its
+  // indexed-column set has drifted from `columns`. Root cause of a silent-write bug class:
+  // a DB created before a column was added to an FTS list (session_summaries_fts predates
+  // `remaining_items`, added v2.2.0) kept the OLD narrow table forever, because ensureFTS
+  // only created the table when it was absent. The triggers below, however, are rebuilt
+  // from the CURRENT (wider) column list, so every UPDATE fired a trigger that INSERTed
+  // into a column the stale FTS table lacked and threw "no column named <X>", silently
+  // failing the write (session-summary Haiku enrichment was discarded every session for the
+  // early-adopter cohort, and the new column stayed unindexed). On drift, drop the triggers +
+  // table and fall through to CREATE + repopulate. Generalizes the one-off observations_fts
+  // guard in ensureDb so ALL three ensureFTS-managed tables self-heal on any column addition.
+  const ftsRow = db.prepare(`SELECT 1 FROM sqlite_master WHERE type='table' AND name=?`).get(ftsName);
+  let recreated = false;
+  if (ftsRow) {
+    let existingCols = [];
+    try { existingCols = db.prepare(`PRAGMA table_info(${ftsName})`).all().map(c => c.name); } catch { /* unreadable → treat as drifted, recreate */ }
+    const drifted = existingCols.length !== columns.length || columns.some(c => !existingCols.includes(c));
+    if (drifted) {
+      db.exec(`DROP TRIGGER IF EXISTS ${tableName}_ai`);
+      db.exec(`DROP TRIGGER IF EXISTS ${tableName}_ad`);
+      db.exec(`DROP TRIGGER IF EXISTS ${tableName}_au`);
+      db.exec(`DROP TABLE IF EXISTS ${ftsName}`);
+      recreated = true;
+    }
+  }
+  if (!ftsRow || recreated) {
     db.exec(`CREATE VIRTUAL TABLE ${ftsName} USING fts5(${colList}, content='${tableName}', content_rowid='id')`);
   }
 
@@ -1001,4 +1041,15 @@ export function ensureFTS(db, ftsName, tableName, columns) {
       INSERT INTO ${ftsName}(rowid, ${colList}) VALUES (new.id, ${newVals});
     END;
   `);
+
+  // Repopulate a freshly (re)created external-content FTS index from its content table.
+  // An empty index otherwise returns 0 rows until each row is next written — and unlike
+  // observations_fts (rebuilt via the obsFtsRecreated flag in ensureDb), session_summaries_fts
+  // and user_prompts_fts have no other rebuild path, so a widened table must repopulate here.
+  if (recreated) {
+    try {
+      const cnt = db.prepare(`SELECT COUNT(*) AS c FROM ${tableName}`).get();
+      if (cnt.c > 0) db.exec(`INSERT INTO ${ftsName}(${ftsName}) VALUES('rebuild')`);
+    } catch { /* non-critical — index repopulates lazily on next write */ }
+  }
 }

package/scripts/post-tool-use.sh

@@ -22,6 +22,12 @@ if [[ "$tool" == "Read" ]]; then
   if [[ "$input" =~ \"file_path\"[[:space:]]*:[[:space:]]*\"([^\"]+)\" ]]; then
     file_path="${BASH_REMATCH[1]}"
     _dir="${CLAUDE_PROJECT_DIR:-$PWD}"
+    # Strip trailing slashes so ${_dir##*/} / ${_dir%/*} match Node's path.basename /
+    # path.dirname in inferProject(). Without this, CLAUDE_PROJECT_DIR="/org/proj/"
+    # gave bash "proj--" (empty base) while JS gave "org--proj" — a name mismatch that
+    # made flushEpisode read a DIFFERENT reads-<project>.txt, silently dropping this
+    # session's Read context AND orphaning the bash-named file (nothing ever collects it).
+    while [[ "$_dir" == */ && ${#_dir} -gt 1 ]]; do _dir="${_dir%/}"; done
     _base="${_dir##*/}"
     _parent="${_dir%/*}"; _parent="${_parent##*/}"
     if [[ -n "$_parent" && "$_parent" != "." && "$_parent" != "/" ]]; then
@@ -29,8 +35,11 @@ if [[ "$tool" == "Read" ]]; then
     else
       project="${_base}"
     fi
-    # Sanitize project name to match utils.mjs inferProject()
+    # Sanitize + truncate to 100 to match utils.mjs inferProject() EXACTLY
+    # (raw.replace(/[^a-zA-Z0-9_.-]/g,'-').slice(0,100)). A >100-char parent--base
+    # otherwise diverges from the JS side (same reads-file mismatch as above).
     project="${project//[^a-zA-Z0-9_.-]/-}"
+    project="${project:0:100}"
     project="${project:-unknown}"
     # Honor CLAUDE_MEM_DIR relocation (mirrors schema.mjs DB_DIR → hook-shared RUNTIME_DIR).
     # hook.mjs flushEpisode reads reads-<project>.txt from CLAUDE_MEM_DIR/runtime; if this

package/search-engine.mjs

@@ -259,6 +259,7 @@ function expandObsByPRF(db, ctx, now, primaryCount, existingIds, results, includ
     SELECT o.title, o.narrative FROM observations_fts
     JOIN observations o ON observations_fts.rowid = o.id
     WHERE observations_fts MATCH ? AND COALESCE(o.compressed_into, 0) = 0
+      AND o.superseded_at IS NULL
       AND (? IS NULL OR o.project = ?)
     ORDER BY ${OBS_BM25}
     LIMIT 8
@@ -304,7 +305,9 @@ function expandObsByPRF(db, ctx, now, primaryCount, existingIds, results, includ
  *   1. FTS5 MATCH with the sanitized query (AND-by-default), recency-weighted
  *   2. If AND returns 0 → relaxFtsQueryToOr fallback (mirrors searchObservationsHybrid)
  *
- * Always skips compressed rows.
+ * Always skips compressed AND superseded rows — paired with searchObservationsHybrid /
+ * buildObsFtsQuery so `timeline --query` / mem_timeline never anchor on a memory that
+ * search itself hides (an anchor on a replaced row strands navigation on stale content).
  *
  * @param {Database} db
  * @param {object} opts
@@ -324,6 +327,7 @@ export function findFtsAnchor(db, { ftsQuery, project = null, nowT = null, halfL
     WHERE observations_fts MATCH ?
       AND (? IS NULL OR o.project = ?)
       AND COALESCE(o.compressed_into, 0) = 0
+      AND o.superseded_at IS NULL
     ORDER BY ${OBS_BM25}
       * (1.0 + EXP(-0.693 * MAX(0, ? - o.created_at_epoch) / ${halfLifeMs}.0))
     LIMIT 1

package/search-scoring.mjs

@@ -199,6 +199,7 @@ export function expandQueryByConcepts(db, ftsQuery, project) {
       SELECT o.concepts FROM observations_fts
       JOIN observations o ON observations_fts.rowid = o.id
       WHERE observations_fts MATCH ? AND COALESCE(o.compressed_into, 0) = 0
+        AND o.superseded_at IS NULL
         AND (? IS NULL OR o.project = ?)
       ORDER BY ${OBS_BM25}
       LIMIT 20
@@ -281,6 +282,11 @@ export function runIdleCleanup(db) {
         WHERE importance <= 1 AND COALESCE(access_count, 0) = 0
           AND type IN (${types})
           AND created_at_epoch < ? AND COALESCE(compressed_into, 0) = 0
+          -- Never auto-mark a lesson-bearing row for purge. This idle path is the
+          -- MCP-server sibling of maintain-core.decayAndMarkIdle and must carry the
+          -- SAME "lessons never auto-GC" guard; without it a lesson demoted to imp≤1
+          -- by citation-decay gets pending-purge'd here and hard-deleted by purgeStale.
+          AND (lesson_learned IS NULL OR lesson_learned = '' OR lesson_learned = 'none')
       `).run(cutoff);
       totalMarked += marked.changes;
 
@@ -289,6 +295,10 @@ export function runIdleCleanup(db) {
         WHERE COALESCE(compressed_into, 0) = 0 AND importance = 1
           AND type IN (${types})
           AND created_at_epoch < ?
+          -- Same lesson guard: auto-compress (-1) hides the row from all retrieval and
+          -- recoverBuriedLessons only re-floors live (compressed_into=0) rows, so a
+          -- compressed lesson is unrecoverable. Parity with selectCompressionCandidates.
+          AND (lesson_learned IS NULL OR lesson_learned = '' OR lesson_learned = 'none')
       `).run(cutoff);
       totalCompressed += compressed.changes;
     }

package/secret-scrub.mjs

@@ -29,9 +29,9 @@ export const SECRET_PATTERNS = [
   // excludes "Marker token: …". `secret` added so a bare SECRET=… with a mixed-alnum
   // value is covered (the hex-only assignment pattern below misses non-hex values).
   //   1a. `=` assignment → ALWAYS scrub (config syntax, never prose):
-  [/((?:\b|_)(?:password|passwd|token|bearer|secret)\s*=\s*)(?!process\.env\.)(?!new\s)(?!\w+\()(?!(?:null|undefined|true|false|None|nil|empty|""|''|0)\b)[^\s,;'"}\]]{6,}/gi, '$1***'],
+  [/((?:\b|_)(?:password|passwd|passphrase|token|bearer|secret)\s*=\s*)(?!process\.env\.)(?!new\s)(?!\w+\()(?!(?:null|undefined|true|false|None|nil|empty|""|''|0)\b)[^\s,;'"}\]]{6,}/gi, '$1***'],
   //   1b. `:` separator → keep the prose lookbehind ("the token: alice" is prose):
-  [/((?<![A-Za-z][ \t])(?:\b|_)(?:password|passwd|token|bearer|secret)\s*:\s*)(?!process\.env\.)(?!new\s)(?!\w+\()(?!(?:null|undefined|true|false|None|nil|empty|""|''|0)\b)[^\s,;'"}\]]{6,}/gi, '$1***'],
+  [/((?<![A-Za-z][ \t])(?:\b|_)(?:password|passwd|passphrase|token|bearer|secret)\s*:\s*)(?!process\.env\.)(?!new\s)(?!\w+\()(?!(?:null|undefined|true|false|None|nil|empty|""|''|0)\b)[^\s,;'"}\]]{6,}/gi, '$1***'],
   // access_token / refresh_token are the canonical OAuth2 field names — they were
   // missing from this KV list (drift vs the JSON list below). `(?:\b|_)` for the same
   // underscore-prefix reason.
@@ -55,8 +55,8 @@ export const SECRET_PATTERNS = [
   //   (a) bare credential nouns: `=` always scrubs; `:` keeps the prose lookbehind
   //       (mirrors the unquoted 1a/1b split — a quoted value doesn't turn `:` prose
   //       into config, but `<word> password="x"` is still a leak):
-  [/((?:\b|_)(?:password|passwd|token|bearer|secret)\s*=\s*)(['"])[^'"]{6,}\2/gi, '$1$2***$2'],
-  [/((?<![A-Za-z][ \t])(?:\b|_)(?:password|passwd|token|bearer|secret)\s*:\s*)(['"])[^'"]{6,}\2/gi, '$1$2***$2'],
+  [/((?:\b|_)(?:password|passwd|passphrase|token|bearer|secret)\s*=\s*)(['"])[^'"]{6,}\2/gi, '$1$2***$2'],
+  [/((?<![A-Za-z][ \t])(?:\b|_)(?:password|passwd|passphrase|token|bearer|secret)\s*:\s*)(['"])[^'"]{6,}\2/gi, '$1$2***$2'],
   //   (b) structured keys + named env vars are unambiguous config even after a word
   //       (`see api_key: "x"` DOES scrub, mirroring the unquoted structured-key path):
   [/((?:\b|_)(?:pgpassword|pgpass|mysql_pwd|api[_-]?key|api[_-]?secret|secret[_-]?key|access[_-]?key|private[_-]?key|client[_-]?secret|auth[_-]?token|access[_-]?token|refresh[_-]?token)\s*[=:]\s*)(['"])[^'"]{6,}\2/gi, '$1$2***$2'],
@@ -121,6 +121,19 @@ export const SECRET_PATTERNS = [
   // `"token_count"` value (numeric, <6 non-quote chars after scrub) and prose
   // keys stay low-FP; over-scrub is the safe direction for at-rest memory.
   [/("\w*(?:password|passwd|secret|api[_-]?key|auth[_-]?token|access[_-]?token|private[_-]?key)\w*"\s*:\s*")[^"]{6,}(")/gi, '$1***$2'],
+  // Quoted-KEY credential values — Python dict reprs `{'api_key': '...'}`, single-quoted
+  // JS/JSON, and any mixed quoting. The quoted-VALUE patterns above match an UNQUOTED key
+  // (the key's closing quote sits between the key name and the `[=:]`, so `keyword\s*[=:]`
+  // never fires); the JSON patterns require BOTH key and value DOUBLE-quoted. So a single-
+  // quoted or mixed-quoted pair — the most common at-rest shape for opaque app secrets in
+  // stored LLM output / error payloads / code snippets — slipped through unredacted (#8805
+  // sibling). A quoted key is unambiguous config/data, so — like the JSON patterns — no prose
+  // guard is needed. Key quote and value quote are matched independently (`['"]` each); the
+  // value's close is a backref (\2) to its own opening quote. Same credential-noun set as the
+  // vendor-prefix JSON pattern above (bare `token`/`bearer` deliberately excluded to avoid
+  // `'token_count': 123456`); `passphrase` added here too (double-quoted JSON passphrase is
+  // subsumed by this pattern since `['"]` matches `"`). Over-scrub is the safe direction.
+  [/(['"]\w*(?:password|passwd|passphrase|secret|api[_-]?key|auth[_-]?token|access[_-]?token|private[_-]?key)\w*['"]\s*:\s*)(['"])[^'"]{6,}\2/gi, '$1$2***$2'],
   // Session cookies in headers / urlencoded bodies (sessionid=, session_id=, JSESSIONID=, PHPSESSID=).
   // 16+ chars filters out short test fixtures like sessionid=abc.
   [/\b((?:session[_-]?id|sessionid|jsessionid|phpsessid)\s*[=:]\s*)[^\s,;'"}\]]{16,}/gi, '$1***'],

package/source-files.mjs

@@ -13,7 +13,7 @@ export const SOURCE_FILES = [
   'plugin-cache-guard.mjs',
   'haiku-client.mjs', 'utils.mjs', 'schema.mjs',
   'package.json', 'package-lock.json', 'skill.md',
-  'registry.mjs', 'registry-scanner.mjs', 'registry-indexer.mjs',
+  'registry.mjs', 'registry-scanner.mjs',
   'registry-retriever.mjs', 'resource-discovery.mjs',
   // registry-recommend.mjs: statically imported by hook.mjs (PostToolUse adoption probe)
   // and scripts/user-prompt-search.js (UserPromptSubmit shadow recommendation).

package/tool-schemas.mjs

@@ -92,7 +92,7 @@ export const memSearchSchema = {
   limit: coerceInt.pipe(z.number().int().min(1).max(100)).optional().describe('Max results (default 20)'),
   offset: coerceInt.pipe(z.number().int().min(0)).optional().describe('Offset for pagination'),
   sort: z.enum(['relevance', 'time', 'importance']).optional().describe('Sort order: relevance (default, BM25), time (newest first), importance (highest first)'),
-  include_noise: z.boolean().optional().describe('Include hook-llm fallback titles ("Modified X", "Worked on X", raw error logs) — hidden by default as they have ~3% access rate'),
+  include_noise: coerceBool.optional().describe('Include hook-llm fallback titles ("Modified X", "Worked on X", raw error logs) — hidden by default as they have ~3% access rate'),
   or: coerceBool.optional().describe('Force OR semantics between query terms from the start (default: AND with automatic OR-fallback when AND returns 0). Aligns with CLI --or.'),
   deep: coerceBool.optional().describe('Tri-state LLM multi-query/HyDE deep search (observations-only). true=force; false=never; omit=AUTO (default ON for mem_search): a normal search that returns weak/few results auto-escalates with ONE Haiku call (query rewritten to keyword/concept/HyDE variants, RRF-fused). Set CLAUDE_MEM_AUTO_DEEP=0 to disable AUTO. Passive recall stays single-query.'),
   rerank: coerceBool.optional().describe('Opt-in: LLM-rerank the deep-search candidates for ranking precision (one extra Haiku call, ~1.4s). Requires deep=true (no effect on AUTO/normal). Reserve for hard, ranking-sensitive queries where the right memory is likely retrieved but mis-ranked — skip for routine search. Default off.'),
@@ -249,7 +249,7 @@ export const memExportSchema = {
 export const memRecallSchema = {
   file: z.string().min(1).describe('File path or filename to recall observations for'),
   limit: coerceInt.pipe(z.number().int().min(1).max(50)).optional().describe('Max results (default 10)'),
-  include_noise: z.boolean().optional().describe('Include hook-llm fallback titles ("Modified X", "Worked on X", raw error logs) — hidden by default for parity with mem_search'),
+  include_noise: coerceBool.optional().describe('Include hook-llm fallback titles ("Modified X", "Worked on X", raw error logs) — hidden by default for parity with mem_search'),
 };
 
 export const memFtsCheckSchema = {

package/utils.mjs

@@ -309,7 +309,11 @@ function firstBalancedJsonObject(text) {
 export function parseJsonFromLLM(text) {
   if (!text) return null;
   try { return JSON.parse(text); } catch {}
-  const fenced = text.match(/```(?:json)?\s*([\s\S]*?)\s*```/);
+  // No `\s*` around the lazy capture: `\s*([\s\S]*?)\s*` catastrophically backtracks
+  // (O(n²)) on a fence + long whitespace + no closing fence — a ~5KB partial buffer hung
+  // the CLI-timeout salvage path for 10+s (round-5 review). `([\s\S]*?)```` is a single
+  // O(n) lazy scan; JSON.parse tolerates the surrounding whitespace the trim used to strip.
+  const fenced = text.match(/```(?:json)?([\s\S]*?)```/);
   if (fenced) try { return JSON.parse(fenced[1]); } catch {}
   // First balanced object — survives unfenced output wrapped in brace-containing prose.
   const balanced = firstBalancedJsonObject(text);

package/registry-indexer.mjs

@@ -1,175 +0,0 @@
-// claude-mem-lite: Resource indexer — extracts metadata via Haiku LLM
-// Called during installation and when resource content changes
-
-import { upsertResource } from './registry.mjs';
-import { callHaikuJSON } from './haiku-client.mjs';
-import { debugLog, debugCatch, truncate } from './utils.mjs';
-
-// ─── Index Prompt ────────────────────────────────────────────────────────────
-
-/**
- * Build the LLM prompt for extracting structured metadata from a resource.
- * @param {object} resource Scanned resource with name, type, and content
- * @returns {string} Prompt string for Haiku JSON extraction
- */
-function buildIndexPrompt(resource) {
-  const content = truncate(resource.content, 3000);
-  return `Analyze this Claude Code ${resource.type} definition and extract structured metadata.
-Return ONLY valid JSON, no markdown fences.
-
-<resource-name>${resource.name}</resource-name>
-<resource-type>${resource.type}</resource-type>
-<content>
-${content}
-</content>
-
-JSON format:
-{"intent_tags":"comma-separated intent keywords (e.g. test,debug,deploy,review)","domain_tags":"comma-separated tech/language tags (e.g. javascript,react,python)","action_type":"analyze|generate|transform|validate|deploy|configure|review","trigger_patterns":"natural language describing when to use this (e.g. when user needs to write tests; when debugging errors)","capability_summary":"50-100 char description of what it does","keywords":"specific technical terms, framework names, method names not duplicating intent_tags (e.g. jest,vitest,red-green-refactor,pytest)","tech_stack":"specific frameworks and tools this works with (e.g. jest,vitest,mocha,pytest)","use_cases":"3-5 specific usage scenarios separated by semicolons","input_type":"code|file|directory|url|text","output_type":"report|file|diff|terminal_output|analysis"}`;
-}
-
-// ─── Fallback Extraction ─────────────────────────────────────────────────────
-
-/**
- * Extract basic metadata from resource content using regex when Haiku fails.
- * Better than nothing — provides minimal FTS5 searchability.
- */
-function fallbackExtract(resource) {
-  const content = (resource.content || '').toLowerCase();
-  const name = resource.name.toLowerCase();
-
-  // Infer intent tags from name and common patterns
-  const intentMap = {
-    commit: 'commit,git,version-control',
-    test: 'test,testing,tdd,qa',
-    debug: 'debug,troubleshoot,fix,error',
-    review: 'review,code-review,quality',
-    lint: 'lint,format,style,quality',
-    deploy: 'deploy,release,ci,cd',
-    build: 'build,compile,bundle',
-    refactor: 'refactor,clean,simplify',
-    security: 'security,audit,vulnerability',
-    perf: 'performance,optimize,benchmark',
-    doc: 'documentation,readme,docs',
-    design: 'design,ui,ux,frontend',
-    infra: 'infrastructure,devops,cloud',
-  };
-
-  const intentTagSet = new Set();
-  for (const [key, tags] of Object.entries(intentMap)) {
-    if (name.includes(key) || content.includes(key)) {
-      for (const t of tags.split(',')) intentTagSet.add(t);
-    }
-  }
-  const intentTags = [...intentTagSet].join(',');
-
-  // Infer domain tags from content
-  const domainPatterns = [
-    [/\b(javascript|typescript|node|npm|yarn|pnpm)\b/, 'javascript,typescript,node'],
-    [/\b(python|pip|poetry|django|flask)\b/, 'python'],
-    [/\b(react|vue|angular|svelte|next)\b/, 'frontend,javascript'],
-    [/\b(rust|cargo)\b/, 'rust'],
-    [/\b(go|golang)\b/, 'go'],
-    [/\b(docker|kubernetes|k8s|terraform)\b/, 'infrastructure,devops'],
-    [/\b(postgres|mysql|sqlite|mongodb)\b/, 'database'],
-    [/\b(api|rest|graphql|grpc)\b/, 'api,backend'],
-  ];
-
-  let domainTags = '';
-  for (const [pattern, tags] of domainPatterns) {
-    if (pattern.test(content)) {
-      domainTags = domainTags ? `${domainTags},${tags}` : tags;
-    }
-  }
-
-  return {
-    intent_tags: intentTags || resource.type,
-    domain_tags: domainTags || '',
-    action_type: resource.type === 'agent' ? 'analyze' : 'generate',
-    trigger_patterns: `when user needs ${name.replace(/-/g, ' ')} functionality`,
-    capability_summary: truncate(`${resource.type}: ${name.replace(/-/g, ' ')}`, 100),
-    input_type: 'code',
-    output_type: resource.type === 'agent' ? 'analysis' : 'file',
-  };
-}
-
-// ─── Single Resource Indexing ────────────────────────────────────────────────
-
-/**
- * Index a single resource: call Haiku for metadata, then upsert to DB.
- * Falls back to regex extraction if Haiku fails.
- * @param {Database} db Registry database
- * @param {object} resource Scanned resource object
- * @returns {Promise<number>} Resource ID
- */
-export async function indexResource(db, resource) {
-  const prompt = buildIndexPrompt(resource);
-  let metadata = await callHaikuJSON(prompt, { timeout: 15000, maxTokens: 400 });
-
-  if (!metadata || !metadata.capability_summary) {
-    debugLog('WARN', 'indexer', `Haiku failed for ${resource.name}, using fallback`);
-    metadata = fallbackExtract(resource);
-  }
-
-  const now = new Date().toISOString();
-  const id = upsertResource(db, {
-    name: resource.name,
-    type: resource.type,
-    status: 'active',
-    source: resource.source,
-    repo_url: resource.repoUrl || null,
-    repo_stars: resource.repoStars || 0,
-    local_path: resource.localPath,
-    file_hash: resource.fileHash,
-    intent_tags: metadata.intent_tags || '',
-    domain_tags: metadata.domain_tags || '',
-    action_type: metadata.action_type || '',
-    trigger_patterns: metadata.trigger_patterns || '',
-    capability_summary: metadata.capability_summary || '',
-    input_type: metadata.input_type || '',
-    output_type: metadata.output_type || '',
-    keywords: metadata.keywords || '',
-    tech_stack: metadata.tech_stack || '',
-    use_cases: metadata.use_cases || '',
-    prerequisites: typeof metadata.prerequisites === 'object'
-      ? JSON.stringify(metadata.prerequisites) : '{}',
-    indexed_at: now,
-  });
-
-  return id;
-}
-
-/**
- * Index multiple resources sequentially.
- * Logs progress and continues on individual failures.
- * @param {Database} db Registry database
- * @param {object[]} resources Array of scanned resources
- * @returns {Promise<{indexed: number, failed: number}>} Results summary
- */
-export async function indexAll(db, resources) {
-  let indexed = 0;
-  let failed = 0;
-
-  for (const resource of resources) {
-    try {
-      await indexResource(db, resource);
-      indexed++;
-      debugLog('DEBUG', 'indexer', `indexed: ${resource.type}/${resource.name}`);
-    } catch (e) {
-      failed++;
-      debugCatch(e, `indexResource(${resource.name})`);
-      // Mark as error in DB so it can be retried later
-      try {
-        upsertResource(db, {
-          name: resource.name,
-          type: resource.type,
-          status: 'error',
-          source: resource.source,
-          local_path: resource.localPath,
-          file_hash: resource.fileHash,
-        });
-      } catch {}
-    }
-  }
-
-  return { indexed, failed };
-}