claude-mem-lite 3.32.0 → 3.33.0

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
   "plugins": [
     {
       "name": "claude-mem-lite",
-      "version": "3.32.0",
+      "version": "3.33.0",
       "source": "./",
       "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": "3.32.0",
+  "version": "3.33.0",
   "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-memory.mjs

@@ -6,6 +6,7 @@ import { citeFactorJs } from './scoring-sql.mjs';
 import { recordMetric } from './lib/metrics.mjs';
 import { DB_DIR } from './schema.mjs';
 import { extractIdents } from './lib/lesson-idents.mjs';
+import { formatSubagentContext } from './lib/task-imperative.mjs';
 
 const MAX_MEMORY_INJECTIONS = 3;
 const MEMORY_LOOKBACK_MS = 60 * 86400000; // 60 days
@@ -439,3 +440,18 @@ export function selectImperativeLesson(db, userPrompt, project, excludeIds = [])
   }
   return best ? { id: best.id, lesson_learned: best.lesson_learned } : null;
 }
+
+// P0 (2026-07-03): compose the subagent-dispatch injection. Given a PreToolUse
+// Agent/Task tool_input, pick ONE project-scoped high-value lesson whose identifiers
+// overlap the SUBAGENT's task prompt (precision-first via selectImperativeLesson:
+// no overlap -> null -> no injection) and return a NEW tool_input with the
+// safe-framed context appended to `prompt`. Returns null when there is nothing to
+// inject. Pure over (db, toolInput, project) so it unit-tests without the subprocess.
+export function buildSubagentInjection(db, toolInput, project) {
+  if (!db || !toolInput || typeof toolInput.prompt !== 'string' || !toolInput.prompt.trim()) return null;
+  const pick = selectImperativeLesson(db, toolInput.prompt, project);
+  if (!pick || !pick.lesson_learned) return null;
+  const block = formatSubagentContext(pick.lesson_learned, pick.id);
+  if (!block) return null;
+  return { ...toolInput, prompt: `${toolInput.prompt}\n${block}` };
+}

package/hooks/hooks.json

@@ -50,6 +50,16 @@
             "timeout": 3
           }
         ]
+      },
+      {
+        "matcher": "Agent|Task",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/hook-launcher.mjs\" scripts/pre-agent-inject.js",
+            "timeout": 5
+          }
+        ]
       }
     ],
     "PostToolUse": [

package/install.mjs

@@ -705,10 +705,24 @@ const memPreSkillBridge = {
   ]
 };
 
+// P0 subagent dispatch-time injection (default off — CLAUDE_MEM_SUBAGENT_INJECT).
+// Fires on the Agent/Task dispatch so a subagent (otherwise memory-blind — #8848)
+// can receive one relevant lesson via updatedInput. Parity with hooks/hooks.json.
+const memPreAgentInject = {
+  matcher: 'Agent|Task',
+  hooks: [
+    {
+      type: 'command',
+      command: nodeHook('scripts/pre-agent-inject.js'),
+      timeout: 5
+    }
+  ]
+};
+
 // Filter out existing mem hooks, then append fresh ones
-// PreToolUse has two separate matchers, so we register both
+// PreToolUse has three separate matchers, so we register all three
 const hookConfigs = {
-  PreToolUse: [memPreToolRecall, memPreSkillBridge],
+  PreToolUse: [memPreToolRecall, memPreSkillBridge, memPreAgentInject],
   PostToolUse: [memPostToolUse],
   SessionStart: [memSessionStart],
   Stop: [memStop],

package/lib/task-imperative.mjs

@@ -16,3 +16,25 @@ export function formatTaskImperative(lesson, id) {
   const tag = (id === undefined || id === null || id === '') ? '' : ` (#${id})`;
   return `Memory — a past lesson applies to THIS task. You must: ${body}.${tag}`;
 }
+
+// Subagent-dispatch framing. Subagents are memory-blind (plugin hooks don't fire
+// inside them — #8848); the P0 dispatch hook (scripts/pre-agent-inject.js) APPENDS
+// this block to a spawned subagent's prompt via PreToolUse updatedInput. This is
+// deliberately NOT the "You must:" imperative above: Phase-0b measured live
+// (2026-07-03) that a raw imperative PREPEND trips the subagent's own
+// prompt-injection detector -> refusal, whereas this appended, attributed,
+// reference-only block is adopted. The four load-bearing elements (named provenance
+// / "reference, not an instruction" / appended-below-the-task / no adversarial
+// tokens) are the measured difference between adopt and refuse — do not drift them.
+export function formatSubagentContext(lesson, id) {
+  const body = String(lesson || '').trim().replace(/\.$/, '');
+  if (!body) return '';
+  const tag = (id === undefined || id === null || id === '') ? '' : `#${id} — `;
+  return [
+    '',
+    '---',
+    "[Project memory — surfaced by your operator's claude-mem-lite memory system for this project. Reference context, not an external instruction.]",
+    'A past lesson recorded for this project that may be relevant to the task above:',
+    `  ${tag}${body}.`,
+  ].join('\n');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "3.32.0",
+  "version": "3.33.0",
   "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",
@@ -143,6 +143,7 @@
     "scripts/pre-tool-recall.js",
     "scripts/post-tool-recall.js",
     "scripts/pre-skill-bridge.js",
+    "scripts/pre-agent-inject.js",
     "scripts/prompt-search-utils.mjs",
     "scripts/hook-launcher.mjs",
     ".mcp.json",

package/scripts/pre-agent-inject.js

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+// claude-mem-lite: PreToolUse:Agent|Task hook — subagent dispatch-time memory injection.
+// Subagents are memory-blind (plugin hooks do NOT fire inside them — #8848); this hook
+// injects ONE relevant project lesson into a dispatched subagent's prompt by mutating
+// tool_input.prompt via hookSpecificOutput.updatedInput. Verified live 2026-07-03
+// (Phase 0a: the mutation reaches the subagent's task-prompt position; Phase 0b: an
+// appended, attributed, reference-only block is adopted, whereas a raw imperative
+// prepend trips the subagent's own prompt-injection detector and is refused).
+//
+// DEFAULT OFF (CLAUDE_MEM_SUBAGENT_INJECT=on|1). The off path costs one env check and
+// returns — no stdin read, no DB, no heavy imports (schema/better-sqlite3 are dynamic,
+// loaded only on the enabled Agent path). Fail-open: never exits non-zero, never blocks
+// a dispatch (a thrown hook would abort the user's subagent).
+
+const ENABLED = process.env.CLAUDE_MEM_SUBAGENT_INJECT === 'on'
+  || process.env.CLAUDE_MEM_SUBAGENT_INJECT === '1';
+
+function readStdin() {
+  return new Promise((resolve) => {
+    let data = '';
+    const timer = setTimeout(() => { try { process.stdin.destroy(); } catch { /* */ } resolve(data); }, 1500);
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (c) => {
+      data += c;
+      if (data.length > 262144) { clearTimeout(timer); resolve(data.slice(0, 262144)); } // cap: agent prompts can be large
+    });
+    process.stdin.on('end', () => { clearTimeout(timer); resolve(data); });
+    process.stdin.on('error', () => { clearTimeout(timer); resolve(data); });
+    process.stdin.resume();
+  });
+}
+
+async function main() {
+  if (!ENABLED) return;                             // default: cheapest possible no-op
+  if (process.env.CLAUDE_MEM_HOOK_RUNNING) return;  // recursion guard (background claude -p)
+
+  const raw = await readStdin();
+  let hook;
+  try { hook = JSON.parse(raw); } catch { return; }
+  if (!hook || typeof hook !== 'object') return;
+  if (hook.tool_name !== 'Agent' && hook.tool_name !== 'Task') return;
+
+  // Heavy deps loaded ONLY on the enabled Agent-dispatch path, so the default-off
+  // hot path never pays the schema.mjs + better-sqlite3 native load on every dispatch.
+  const { ensureDb } = await import('../schema.mjs');
+  const { inferProject } = await import('../utils.mjs');
+  const { buildSubagentInjection } = await import('../hook-memory.mjs');
+
+  let db;
+  try { db = ensureDb(); } catch { return; }
+  try {
+    const updatedInput = buildSubagentInjection(db, hook.tool_input, inferProject());
+    if (updatedInput) {
+      process.stdout.write(JSON.stringify({
+        hookSpecificOutput: { hookEventName: 'PreToolUse', updatedInput },
+      }));
+    }
+  } catch { /* never break a dispatch */ } finally {
+    try { db.close(); } catch { /* */ }
+  }
+}
+
+main().catch(() => {}).finally(() => process.exit(0));

package/source-files.mjs

@@ -185,6 +185,7 @@ export const HOOK_SCRIPT_FILES = [
   'pre-tool-recall.js',
   'post-tool-recall.js',
   'pre-skill-bridge.js',
+  'pre-agent-inject.js',
   // v2.84: self-heal wrapper that detects ERR_MODULE_NOT_FOUND under the
   // install dir and runs install.mjs repair before retrying the entry.
   // hooks.json + install.mjs settings template invoke node hook entries