claude-mem-lite 2.12.2 → 2.13.1

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
   "plugins": [
     {
       "name": "claude-mem-lite",
-      "version": "2.12.2",
+      "version": "2.13.1",
       "source": "./",
       "description": "Lightweight persistent memory system for Claude Code — FTS5 search, episode batching, error-triggered recall"
     }

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "2.12.2",
+  "version": "2.13.1",
   "description": "Lightweight persistent memory system for Claude Code — FTS5 search, episode batching, error-triggered recall",
   "author": {
     "name": "sdsrss"

package/cli.mjs

@@ -1,4 +1,12 @@
 #!/usr/bin/env node
-import { main } from './install.mjs';
+const CLI_COMMANDS = new Set(['search', 'recent', 'recall', 'get', 'timeline', 'save', 'stats', 'context', 'help']);
 
-await main(process.argv.slice(2));
+const cmd = process.argv[2];
+
+if (CLI_COMMANDS.has(cmd)) {
+  const { run } = await import('./mem-cli.mjs');
+  await run(process.argv.slice(2));
+} else {
+  const { main } = await import('./install.mjs');
+  await main(process.argv.slice(2));
+}

package/commands/mem.md

@@ -2,39 +2,36 @@
 description: Search and manage project memory (observations, sessions, prompts)
 ---
 
-# Memory Skill
+# Memory
 
 Search and browse your project memory efficiently.
 
-## Commands
+## Quick Commands
 
-- `/mem search <query>` — FTS5 full-text search across all memories
-- `/mem recent [n]` — Show recent N observations (default 10)
+- `/mem search <query>` — Search all memories (FTS5 full-text search)
+- `/mem recent [n]` — Show recent N observations (default 5)
+- `/mem recall <file>` — History for a file before editing
+- `/mem timeline <id>` — Browse timeline around an observation
 - `/mem save <text>` — Save a manual memory/note
 - `/mem stats` — Show memory statistics
-- `/mem timeline <query>` — Browse timeline around a matching observation
 - `/mem cleanup` — Scan and interactively purge stale data
 - `/mem cleanup [N]d` — Purge stale data older than N days (e.g. `cleanup 60d`)
 - `/mem cleanup keep [N]d` — Purge stale data but retain last N days (e.g. `cleanup keep 14d`)
 
-## Efficient Search Workflow (3 steps, saves 10x tokens)
-
-1. **Search** → `mem_search(query="...")` → get compact ID index
-2. **Browse** → `mem_timeline(anchor=ID)` → see surrounding context
-3. **Detail** → `mem_get(ids=[...])` → get full content for specific IDs
-
 ## Instructions
 
 When the user invokes `/mem`, parse their intent:
 
-- `/mem search <query>` → call `mem_search` with the query
-- `/mem recent` or `/mem recent 20` → call `mem_search` with no query, limit=N
-- `/mem save <text>` → call `mem_save` with the text as content
-- `/mem stats` → call `mem_stats`
-- `/mem timeline <query>` → call `mem_timeline` with the query
+- `/mem search <query>` → run `claude-mem-lite search <query>` via Bash
+- `/mem recent` or `/mem recent 20` → run `claude-mem-lite recent [N]` via Bash
+- `/mem recall <file>` → run `claude-mem-lite recall <file>` via Bash
+- `/mem timeline <id>` → run `claude-mem-lite timeline --anchor <id>` via Bash
+- `/mem save <text>` → call `mem_save` MCP tool with the text as content
+- `/mem stats` → run `claude-mem-lite stats` via Bash
+- `/mem get <ids>` → run `claude-mem-lite get <ids>` via Bash
 - `/mem cleanup` → run `mem_maintain(action="scan")`, report pending purge count and stale items to user, ask for confirmation, then run `mem_maintain(action="execute", operations=["purge_stale"])` if confirmed
 - `/mem cleanup Nd` (e.g. `60d`) → same as above but use `retain_days=N` to only purge items older than N days
 - `/mem cleanup keep Nd` (e.g. `keep 14d`) → same as above with `retain_days=N`
-- `/mem <query>` (no subcommand) → treat as search, call `mem_search`
+- `/mem <query>` (no subcommand) → treat as search, run `claude-mem-lite search <query>` via Bash
 
-Always use the compact index from mem_search first, then mem_get for details only when needed. This minimizes token usage.
+Use Bash commands first. For detailed data, use `claude-mem-lite get <id>` via Bash.

package/commands/recall.md

@@ -0,0 +1,9 @@
+---
+description: Recall past observations for a file before editing
+argument-hint: <file_path>
+---
+
+## File Memory
+!`claude-mem-lite recall $ARGUMENTS 2>/dev/null || echo "No history found"`
+
+Consider these past observations before making changes.

package/commands/recent.md

@@ -0,0 +1,7 @@
+---
+description: Show recent memory observations
+argument-hint: [count]
+---
+
+## Recent Observations
+!`claude-mem-lite recent $ARGUMENTS 2>/dev/null || echo "No observations"`

package/commands/search.md

@@ -0,0 +1,9 @@
+---
+description: Search memory for past bugfixes, decisions, discoveries
+argument-hint: <query>
+---
+
+## Memory Search
+!`claude-mem-lite search $ARGUMENTS 2>/dev/null || echo "No results found"`
+
+Use `claude-mem-lite get <id>` via Bash for full details on any result.

package/commands/timeline.md

@@ -0,0 +1,7 @@
+---
+description: Browse memory timeline around an observation
+argument-hint: <observation_id>
+---
+
+## Timeline
+!`claude-mem-lite timeline --anchor $ARGUMENTS 2>/dev/null || echo "Not found"`

package/hook-shared.mjs

@@ -4,10 +4,9 @@
 import { execFileSync, spawn } from 'child_process';
 import { randomUUID } from 'crypto';
 import { join } from 'path';
-import { existsSync, readFileSync, writeFileSync, appendFileSync, mkdirSync, renameSync, unlinkSync } from 'fs';
+import { existsSync, readFileSync, writeFileSync, mkdirSync, renameSync } from 'fs';
 import { inferProject, debugCatch } from './utils.mjs';
-import { ensureDb, DB_DIR, REGISTRY_DB_PATH } from './schema.mjs';
-import { ensureRegistryDb } from './registry.mjs';
+import { ensureDb, DB_DIR } from './schema.mjs';
 import { getClaudePath as getClaudePathShared, resolveModel as resolveModelShared } from './haiku-client.mjs';
 
 // ─── Constants ────────────────────────────────────────────────────────────────
@@ -24,7 +23,6 @@ export const STALE_LOCK_MS = 30000;                       // 30s
 export const DEDUP_WINDOW_MS = 5 * 60 * 1000;            // 5 min (title dedup)
 export const RELATED_OBS_WINDOW_MS = 7 * 86400000;       // 7 days
 export const FALLBACK_OBS_WINDOW_MS = RELATED_OBS_WINDOW_MS; // same window
-export const RESOURCE_RESCAN_INTERVAL_MS = 60 * 60 * 1000;    // 1 hour
 
 // Handoff system constants
 export const HANDOFF_EXPIRY_CLEAR = 6 * 3600000;                // 6 hours (covers lunch/meeting breaks)
@@ -69,20 +67,6 @@ export function openDb() {
   }
 }
 
-// ─── Registry Database (dispatch system) ─────────────────────────────────────
-let _registryDb = null;
-
-export function getRegistryDb() {
-  if (_registryDb) return _registryDb;
-  try { _registryDb = ensureRegistryDb(REGISTRY_DB_PATH); } catch (e) { debugCatch(e, 'getRegistryDb'); }
-  return _registryDb;
-}
-
-export function closeRegistryDb() {
-  if (_registryDb) try { _registryDb.close(); } catch {}
-  _registryDb = null;
-}
-
 // ─── LLM via claude CLI ─────────────────────────────────────────────────────
 
 export function callLLM(prompt, timeoutMs = 15000) {
@@ -127,75 +111,6 @@ export function spawnBackground(bgEvent, ...extraArgs) {
 
 export function sleep(ms) { return new Promise(r => setTimeout(r, ms)); }
 
-// ─── Injection Budget (per hook invocation, in-memory) ───────────────────────
-// Limits context injections within a single hook process to prevent context bloat.
-// Note: each hook event runs in a separate process, so this is per-invocation,
-// not per-session. Session-level dedup is handled by cooldown/sessionId checks.
-
-export const MAX_INJECTIONS_PER_SESSION = 3;
-let _injectionCount = 0;
-
-export function getInjectionCount() { return _injectionCount; }
-export function incrementInjection() { _injectionCount++; }
-export function resetInjectionBudget() { _injectionCount = 0; }
-export function hasInjectionBudget() { return _injectionCount < MAX_INJECTIONS_PER_SESSION; }
-
-// ─── Previous Session Context (for user-prompt dispatch enrichment) ──────────
-// Session-start caches next_steps; first user-prompt reads+clears for richer dispatch.
-
-// ─── Tool Event Tracking (for dispatch feedback) ────────────────────────────
-// PostToolUse appends feedback-relevant tool events (Skill, Task, Edit, Write, Bash errors).
-// Stop handler reads them and passes to collectFeedback for adoption/outcome detection.
-
-export function toolEventsFile() {
-  return join(RUNTIME_DIR, `tool-events-${inferProject()}.jsonl`);
-}
-
-/**
- * Append a tool event for feedback tracking.
- * Only call for feedback-relevant events (Skill, Task, Edit, Write, Bash).
- * @param {object} event { tool_name, tool_input, tool_response }
- */
-export function appendToolEvent(event) {
-  try {
-    appendFileSync(toolEventsFile(), JSON.stringify(event) + '\n');
-  } catch {}
-}
-
-/**
- * Read all tracked tool events and remove the file.
- * Uses rename→read→delete for atomicity.
- * @returns {object[]} Array of tool event objects
- */
-export function readAndClearToolEvents() {
-  const file = toolEventsFile();
-  const claimFile = file + `.claim-${process.pid}-${Date.now()}`;
-  try {
-    renameSync(file, claimFile);
-    const raw = readFileSync(claimFile, 'utf8');
-    try { unlinkSync(claimFile); } catch {}
-    return raw.trim().split('\n').filter(Boolean).map(line => {
-      try { return JSON.parse(line); } catch { return null; }
-    }).filter(Boolean);
-  } catch {
-    return [];
-  }
-}
-
-/**
- * Read tracked tool events WITHOUT clearing the file.
- * Used by dispatch to detect active suites mid-session.
- * @returns {object[]} Array of tool event objects
- */
-export function peekToolEvents() {
-  try {
-    const raw = readFileSync(toolEventsFile(), 'utf8');
-    return raw.trim().split('\n').filter(Boolean).map(line => {
-      try { return JSON.parse(line); } catch { return null; }
-    }).filter(Boolean);
-  } catch { return []; }
-}
-
 /**
  * Extract partial response from CLI error output (timeout/error recovery).
  * @param {Error} error The caught error from execFileSync

package/hook-update.mjs

@@ -194,13 +194,12 @@ export function getCurrentVersion() {
 // ── Source files to copy (must match install.mjs SOURCE_FILES) ──
 const SOURCE_FILES = [
   'server.mjs', 'server-internals.mjs', 'tool-schemas.mjs',
-  'hook.mjs', 'hook-shared.mjs', 'hook-llm.mjs', 'hook-memory.mjs',
+  'hook.mjs', 'hook-shared.mjs', 'hook-llm.mjs', 'hook-memory.mjs', 'skip-tools.mjs',
   'hook-semaphore.mjs', 'hook-episode.mjs', 'hook-context.mjs', 'hook-handoff.mjs', 'hook-update.mjs',
   'haiku-client.mjs', 'utils.mjs', 'schema.mjs', 'package.json', 'package-lock.json', 'skill.md',
   'registry.mjs', 'registry-scanner.mjs', 'registry-indexer.mjs',
   'registry-retriever.mjs', 'resource-discovery.mjs',
-  'dispatch.mjs', 'dispatch-inject.mjs', 'dispatch-feedback.mjs', 'dispatch-patterns.mjs', 'dispatch-workflow.mjs',
-  'install.mjs', 'install-metadata.mjs',
+  'install.mjs', 'install-metadata.mjs', 'mem-cli.mjs',
 ];
 const SWITCHABLE_PATHS = [...SOURCE_FILES, 'scripts', 'registry', 'node_modules'];
 

package/hook.mjs

@@ -21,15 +21,11 @@ import {
   writePendingEntry, mergePendingEntries, episodeHasSignificantContent,
 } from './hook-episode.mjs';
 import { selectWithTokenBudget, updateClaudeMd, buildSummaryLines } from './hook-context.mjs';
-import { dispatchOnPreToolUse, dispatchOnUserPrompt } from './dispatch.mjs';
-import { collectFeedback } from './dispatch-feedback.mjs';
 import {
   RUNTIME_DIR, EPISODE_BUFFER_SIZE, EPISODE_TIME_GAP_MS,
   SESSION_EXPIRY_MS, STALE_SESSION_MS, STALE_LOCK_MS, FALLBACK_OBS_WINDOW_MS,
-  RESOURCE_RESCAN_INTERVAL_MS,
-  sessionFile, getSessionId, createSessionId, openDb, getRegistryDb,
-  closeRegistryDb, spawnBackground, appendToolEvent, readAndClearToolEvents,
-  resetInjectionBudget, hasInjectionBudget, incrementInjection,
+  sessionFile, getSessionId, createSessionId, openDb,
+  spawnBackground,
 } from './hook-shared.mjs';
 import { handleLLMEpisode, handleLLMSummary, saveObservation, buildImmediateObservation } from './hook-llm.mjs';
 import { searchRelevantMemories, recallForFile } from './hook-memory.mjs';
@@ -38,9 +34,9 @@ import { checkForUpdate } from './hook-update.mjs';
 import { SKIP_TOOLS, SKIP_PREFIXES } from './skip-tools.mjs';
 
 // Prevent recursive hooks from background claude -p calls
-// Background workers (llm-episode, llm-summary, resource-scan) are exempt — they're ours
+// Background workers (llm-episode, llm-summary) are exempt — they're ours
 const event = process.argv[2];
-const BG_EVENTS = new Set(['llm-episode', 'llm-summary', 'resource-scan']);
+const BG_EVENTS = new Set(['llm-episode', 'llm-summary']);
 
 // Respect Claude Code plugin disable state even when legacy settings.json hooks remain.
 // install.mjs writes direct hooks into ~/.claude/settings.json, so disabling the plugin
@@ -253,21 +249,6 @@ async function handlePostToolUse() {
 
     writeEpisode(episode);
 
-    // Track feedback-relevant tool events for dispatch adoption detection.
-    // Skill/Agent: adoption detection checks these tool names.
-    // Edit/Write/NotebookEdit: outcome detection checks for edits.
-    // Grep: investigation signal for debugging pattern detection.
-    // Bash errors: outcome detection checks for error signals.
-    // Bash test/build success: TDD and verification pattern detection.
-    const isTrackableBash = tool_name === 'Bash' && (bashSig?.isError || bashSig?.isTest || bashSig?.isBuild);
-    if (['Skill', 'Agent', 'Edit', 'Write', 'NotebookEdit', 'Grep'].includes(tool_name) || isTrackableBash) {
-      appendToolEvent({
-        tool_name,
-        tool_input: toolInput,
-        tool_response: (tool_name === 'Bash' && bashSig?.isSignificant) ? scrubSecrets(resp.slice(0, 500)) : '',
-        timestamp: Date.now(),
-      });
-    }
   } finally {
     releaseLock();
     if (db) try { db.close(); } catch {}
@@ -396,18 +377,6 @@ async function handleStop() {
     }
   }
 
-  // Dispatch: collect feedback on recommendations using actual tool events
-  // PostToolUse tracks Skill/Task/Edit/Write/Bash events in a JSONL file.
-  // These events drive adoption detection (Skill/Task) and outcome detection (Edit/Bash errors).
-  // Always clear event file to prevent stale events accumulating if registry DB is unavailable.
-  try {
-    const sessionEvents = readAndClearToolEvents();
-    const rdb = getRegistryDb();
-    if (rdb) {
-      await collectFeedback(rdb, sessionId, sessionEvents);
-    }
-  } catch (e) { debugCatch(e, 'handleStop-feedback'); }
-
   // Spawn background for session summary (pass sessionId and project)
   spawnBackground('llm-summary', sessionId, project);
 
@@ -418,8 +387,6 @@ async function handleStop() {
 // ─── SessionStart Handler + CLAUDE.md Persistence (Tier 1 A, E) ─────────────
 
 async function handleSessionStart() {
-  resetInjectionBudget();
-
   // Snapshot episode BEFORE flush for handoff extraction
   const episodeSnapshot = readEpisodeRaw();
 
@@ -538,15 +505,6 @@ async function handleSessionStart() {
         ).get(prevProject || project, 'clear');
       } catch {}
 
-      // Collect dispatch feedback for previous session
-      try {
-        const rdb = getRegistryDb();
-        if (rdb) {
-          const sessionEvents = readAndClearToolEvents();
-          await collectFeedback(rdb, prevSessionId, sessionEvents);
-        }
-      } catch (e) { debugCatch(e, 'session-start-prev-feedback'); }
-
       // Generate session summary for previous session (background Haiku — richer version)
       spawnBackground('llm-summary', prevSessionId, prevProject || project);
 
@@ -759,13 +717,6 @@ async function handleSessionStart() {
     // CLAUDE.md: slim (summary + handoff state — observations already in stdout)
     updateClaudeMd([...summaryLines, ...handoffLines].join('\n'));
 
-    // Background rescan: detect changed/new managed resources since last scan.
-    // TTL-based (1h) — avoids redundant filesystem scans on every session.
-    // Non-blocking: spawns detached worker, results available before first user prompt.
-    if (needsResourceRescan()) {
-      spawnBackground('resource-scan');
-    }
-
     // Auto-update check (24h throttle, 3s timeout, silent on failure)
     // Fire-and-forget: don't block SessionStart for up to 3s network timeout
     checkForUpdate().then(updateResult => {
@@ -784,51 +735,6 @@ async function handleSessionStart() {
   }
 }
 
-// ─── PreToolUse Handler (Dispatch) ──────────────────────────────────────────
-
-async function handlePreToolUse() {
-  let raw;
-  try { raw = await readStdin(); } catch { return; }
-
-  let hookData;
-  try { hookData = JSON.parse(raw.text); } catch { return; }
-
-  const rdb = getRegistryDb();
-  if (!rdb) return;
-
-  // Quick session context from user prompts DB + episode buffer
-  const sessionId = getSessionId();
-  const sessionCtx = { sessionId };
-  const db = openDb();
-  if (db) {
-    try {
-      const latest = db.prepare(
-        'SELECT prompt_text FROM user_prompts WHERE content_session_id = ? ORDER BY created_at_epoch DESC LIMIT 1'
-      ).get(sessionId);
-      if (latest) sessionCtx.userPrompt = latest.prompt_text;
-    } catch (e) { debugCatch(e, 'handlePreToolUse-queryPrompt'); } finally { db.close(); }
-  }
-  // Collect recent file paths from episode buffer for tech stack inference
-  try {
-    const episode = readEpisodeRaw();
-    if (episode?.entries) {
-      const files = new Set();
-      for (const e of episode.entries) {
-        if (e.files) for (const f of e.files) files.add(f);
-      }
-      if (files.size > 0) sessionCtx.recentFiles = [...files].slice(-10);
-    }
-  } catch {}
-
-  if (hasInjectionBudget()) {
-    const injection = await dispatchOnPreToolUse(rdb, hookData, sessionCtx);
-    if (injection) {
-      process.stdout.write(injection + '\n');
-      incrementInjection();
-    }
-  }
-}
-
 // ─── UserPromptSubmit Handler ────────────────────────────────────────────────
 
 async function handleUserPrompt() {
@@ -874,13 +780,12 @@ async function handleUserPrompt() {
     );
 
     // Cross-session handoff injection (first 3 prompts window, before semantic memory)
-    if (counter?.prompt_counter <= 3 && hasInjectionBudget()) {
+    if (counter?.prompt_counter <= 3) {
       try {
         if (detectContinuationIntent(db, promptText, project)) {
           const injection = renderHandoffInjection(db, project);
           if (injection) {
             process.stdout.write(injection + '\n');
-            incrementInjection();
             // Consume clear handoff after injection to prevent duplicate injection on prompts 2-3.
             // Exit handoffs are kept (7d TTL, content-dependent keyword/FTS matching won't re-trigger).
             try { db.prepare("DELETE FROM session_handoffs WHERE project = ? AND type = 'clear'").run(project); } catch {}
@@ -890,44 +795,29 @@ async function handleUserPrompt() {
     }
 
     // Semantic memory injection: search past observations for the user's prompt
-    if (hasInjectionBudget()) {
-      try {
-        const keyObs = db.prepare(`
-          SELECT id FROM observations
-          WHERE project = ? AND COALESCE(compressed_into, 0) = 0
-            AND COALESCE(importance, 1) >= 2
-          ORDER BY created_at_epoch DESC LIMIT 5
-        `).all(project);
-        const keyContextIds = keyObs.map(o => o.id);
-
-        const memories = searchRelevantMemories(db, promptText, project, keyContextIds);
-        if (memories.length > 0) {
-          const lines = ['<memory-context relevance="high">'];
-          for (const m of memories) {
-            const lessonTag = m.lesson_learned ? ` | Lesson: ${m.lesson_learned}` : '';
-            lines.push(`- [${m.type}] ${truncate(m.title, 80)}${lessonTag} (#${m.id})`);
-          }
-          lines.push('</memory-context>');
-          process.stdout.write(lines.join('\n') + '\n');
-          incrementInjection();
+    try {
+      const keyObs = db.prepare(`
+        SELECT id FROM observations
+        WHERE project = ? AND COALESCE(compressed_into, 0) = 0
+          AND COALESCE(importance, 1) >= 2
+        ORDER BY created_at_epoch DESC LIMIT 5
+      `).all(project);
+      const keyContextIds = keyObs.map(o => o.id);
+
+      const memories = searchRelevantMemories(db, promptText, project, keyContextIds);
+      if (memories.length > 0) {
+        const lines = ['<memory-context relevance="high">'];
+        for (const m of memories) {
+          const lessonTag = m.lesson_learned ? ` | Lesson: ${m.lesson_learned}` : '';
+          lines.push(`- [${m.type}] ${truncate(m.title, 80)}${lessonTag} (#${m.id})`);
         }
-      } catch (e) { debugCatch(e, 'handleUserPrompt-memory'); }
-    }
+        lines.push('</memory-context>');
+        process.stdout.write(lines.join('\n') + '\n');
+      }
+    } catch (e) { debugCatch(e, 'handleUserPrompt-memory'); }
   } finally {
     db.close();
   }
-
-  // Dispatch: only fires for explicit user requests ("I need X skill", "find me a tool for Y")
-  try {
-    const rdb = getRegistryDb();
-    if (rdb && hasInjectionBudget()) {
-      const result = await dispatchOnUserPrompt(rdb, promptText, sessionId);
-      if (result) {
-        process.stdout.write(result + '\n');
-        incrementInjection();
-      }
-    }
-  } catch (e) { debugCatch(e, 'handleUserPrompt-dispatch'); }
 }
 
 // ─── Auto-Compress (Background Worker) ───────────────────────────────────────
@@ -1001,77 +891,6 @@ function handleAutoCompress() {
   }
 }
 
-// ─── Resource Rescan (Background Worker) ─────────────────────────────────────
-
-const RESCAN_MARKER = join(RUNTIME_DIR, 'last-resource-scan');
-
-/**
- * Check if resource rescan is needed (marker older than RESOURCE_RESCAN_INTERVAL_MS).
- * @returns {boolean}
- */
-function needsResourceRescan() {
-  try {
-    const marker = statSync(RESCAN_MARKER);
-    return (Date.now() - marker.mtimeMs) > RESOURCE_RESCAN_INTERVAL_MS;
-  } catch {
-    return true; // No marker = never scanned
-  }
-}
-
-/**
- * Background worker: scan filesystem for changed resources, upsert any diffs.
- * Spawned by SessionStart when marker is stale. Non-blocking to the hook caller.
- */
-async function handleResourceScan() {
-  const rdb = getRegistryDb();
-  if (!rdb) return;
-
-  try {
-    const { scanAllResources, diffResources } = await import('./registry-scanner.mjs');
-    const { upsertResource } = await import('./registry.mjs');
-
-    const scanned = scanAllResources();
-    const { toIndex, toDisable } = diffResources(rdb, scanned);
-
-    if (toIndex.length === 0 && toDisable.length === 0) {
-      // Touch marker even if nothing changed — avoids rescanning every session
-      writeFileSync(RESCAN_MARKER, String(Date.now()));
-      return;
-    }
-
-    // Upsert changed resources with fallback metadata (no Haiku)
-    let upsertErrors = 0;
-    for (const res of toIndex) {
-      try {
-        upsertResource(rdb, {
-          name: res.name,
-          type: res.type,
-          status: 'active',
-          source: res.source,
-          repo_url: res.repoUrl || null,
-          local_path: res.localPath,
-          file_hash: res.fileHash,
-          intent_tags: res.name.replace(/-/g, ' ').replace(/\//g, ' '),
-          trigger_patterns: `when user needs ${res.name.replace(/-/g, ' ').replace(/\//g, ' ')}`,
-          capability_summary: `${res.type}: ${res.name.replace(/-/g, ' ')}`,
-        });
-      } catch (e) { upsertErrors++; if (upsertErrors <= 3) debugCatch(e, `handleResourceScan-upsert[${upsertErrors}]`); }
-    }
-
-    // Disable resources no longer on filesystem
-    for (const row of toDisable) {
-      try {
-        rdb.prepare("UPDATE resources SET status = 'disabled', updated_at = datetime('now') WHERE id = ?").run(row.id);
-      } catch {}
-    }
-
-    debugLog('DEBUG', 'resource-scan', `indexed ${toIndex.length}, disabled ${toDisable.length}`);
-    writeFileSync(RESCAN_MARKER, String(Date.now()));
-  } catch (e) {
-    debugCatch(e, 'handleResourceScan');
-  }
-}
-
 // ─── Utilities ──────────────────────────────────────────────────────────────
 
 function readStdin() {
@@ -1137,14 +956,12 @@ function normalizeToolResponse(toolResponse) {
 
 try {
   switch (event) {
-    case 'pre-tool-use':     await handlePreToolUse(); break;
     case 'post-tool-use':    await handlePostToolUse(); break;
     case 'session-start':    await handleSessionStart(); break;
     case 'stop':             await handleStop(); break;
     case 'user-prompt':      await handleUserPrompt(); break;
     case 'llm-episode':      await handleLLMEpisode(); break;
     case 'llm-summary':      await handleLLMSummary(); break;
-    case 'resource-scan':    await handleResourceScan(); break;
     case 'auto-compress':    handleAutoCompress(); break;
   }
 } catch (err) {
@@ -1153,7 +970,4 @@ try {
   console.error(`[claude-mem-lite] [${ts}] [ERROR] ${event}: ${err.message}`);
 }
 
-// Close singleton registry DB to prevent WAL residue
-closeRegistryDb();
-
 process.exit(0);

package/hooks/hooks.json

@@ -18,18 +18,6 @@
         ]
       }
     ],
-    "PreToolUse": [
-      {
-        "matcher": "*",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hook.mjs\" pre-tool-use",
-            "timeout": 2
-          }
-        ]
-      }
-    ],
     "PostToolUse": [
       {
         "matcher": "*",
@@ -58,6 +46,11 @@
       {
         "matcher": "*",
         "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/user-prompt-search.js\"",
+            "timeout": 2
+          },
           {
             "type": "command",
             "command": "node \"${CLAUDE_PLUGIN_ROOT}/hook.mjs\" user-prompt",