remem-mcp 0.6.2 → 0.6.4

package/dist/index.js

@@ -13,20 +13,26 @@ import {
   redact,
   searchWiki,
   stripQueryProperNouns
-} from "./chunk-ULMM6LKD.js";
+} from "./chunk-X4ECGLYH.js";
 import {
-  __dirname,
-  __toCommonJS,
+  engine_exports,
   findCallees,
   findCallers,
   generateId,
   impactAnalysis,
   indexDirectory,
   indexFile,
-  init_esm_shims,
+  init_engine,
+  init_ulid,
   listSymbols,
   searchSymbols
-} from "./chunk-SHLLMMMU.js";
+} from "./chunk-FA324IBN.js";
+import {
+  __dirname,
+  __require,
+  __toCommonJS,
+  init_esm_shims
+} from "./chunk-XK4Y53J2.js";
 
 // src/index.ts
 init_esm_shims();
@@ -36,7 +42,7 @@ import { homedir as homedir12 } from "os";
 import { dirname as dirname10, join as join15 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import Database12 from "better-sqlite3";
+import Database13 from "better-sqlite3";
 import * as sqliteVec4 from "sqlite-vec";
 
 // src/artifact.ts
@@ -262,8 +268,93 @@ async function atomsCommand(dbPath, flags) {
   }
 }
 
+// src/cli/consolidate.ts
+init_esm_shims();
+init_ulid();
+async function consolidateCommand(dbPath, flags) {
+  const storage = new SQLiteBackend(dbPath);
+  try {
+    if (flags.list !== void 0) {
+      const scenarios = await storage.listScenarios({
+        teamId: flags["team-id"],
+        limit: flags.limit ? Number(flags.limit) : 20
+      });
+      if (scenarios.length === 0) {
+        console.log("No scenarios found.");
+        return;
+      }
+      console.log(`Scenarios (${scenarios.length}):`);
+      for (const s of scenarios) {
+        const tags2 = s.personaTags ? ` [${s.personaTags.join(", ")}]` : "";
+        console.log(`  ${s.id}  ${s.atomIds.length} atoms${tags2}`);
+        console.log(`    ${s.summary}`);
+      }
+      return;
+    }
+    if (flags.auto !== void 0) {
+      const atoms = await storage.listAtoms({
+        teamId: flags["team-id"],
+        limit: flags.limit ? Number(flags.limit) : 100
+      });
+      if (atoms.length < 5) {
+        console.log(`Not enough atoms to consolidate (${atoms.length} < 5).`);
+        return;
+      }
+      const groups = /* @__PURE__ */ new Map();
+      for (const a of atoms) {
+        const words = a.fact.toLowerCase().split(/\s+/).filter((w) => w.length > 3);
+        const key = words[0] ?? "misc";
+        if (!groups.has(key)) groups.set(key, []);
+        groups.get(key).push(a);
+      }
+      let count = 0;
+      for (const [topic, groupAtoms] of groups) {
+        if (groupAtoms.length < 3) continue;
+        const summary2 = groupAtoms.slice(0, 5).map((a) => a.fact).join("; ");
+        const id2 = generateId();
+        await storage.putScenario({
+          id: id2,
+          atomIds: groupAtoms.map((a) => a.id),
+          summary: summary2.slice(0, 300),
+          personaTags: [topic],
+          createdAt: Date.now()
+        });
+        console.log(`  [${topic}] ${groupAtoms.length} atoms \u2192 ${id2}`);
+        count++;
+      }
+      console.log(`
+Created ${count} scenario(s).`);
+      return;
+    }
+    const atomIdsStr = flags["atom-ids"];
+    const summary = flags.summary;
+    if (!atomIdsStr || !summary) {
+      console.error('Usage: remem-mcp consolidate --atom-ids <id1,id2,...> --summary "..."');
+      process.exit(1);
+    }
+    const atomIds = atomIdsStr.split(",").map((s) => s.trim()).filter(Boolean);
+    if (atomIds.length === 0) {
+      console.error("Error: No atom IDs provided.");
+      process.exit(1);
+    }
+    const tags = flags.tags ? flags.tags.split(",").map((s) => s.trim()) : void 0;
+    const id = generateId();
+    await storage.putScenario({
+      id,
+      atomIds,
+      summary,
+      personaTags: tags,
+      createdAt: Date.now()
+    });
+    console.log(`Consolidated ${atomIds.length} atoms into scenario ${id}.`);
+  } finally {
+    storage.close();
+  }
+}
+
 // src/cli/demo.ts
 init_esm_shims();
+init_engine();
 import { execSync, spawn } from "child_process";
 import { createHash as createHash2 } from "crypto";
 import { existsSync as existsSync3, mkdirSync as mkdirSync3, mkdtempSync, readFileSync as readFileSync2, rmSync, writeFileSync } from "fs";
@@ -813,6 +904,7 @@ init_local();
 
 // src/pipeline/atom.ts
 init_esm_shims();
+init_ulid();
 var AtomPipeline = class {
   name = "atom";
   requiresLLM = true;
@@ -869,10 +961,10 @@ var RuleBasedAtomPipeline = class {
   name = "rule-atom";
   requiresLLM = false;
   async process(input, ctx) {
-    if (input.type !== "conversation") {
+    if (!["decision", "learning", "error", "conversation"].includes(input.type)) {
       return {};
     }
-    const facts = extractMigrationFacts(input.content);
+    const facts = extractRuleBasedFacts(input.content, input.type);
     if (facts.length === 0) {
       return {};
     }
@@ -897,16 +989,50 @@ var RuleBasedAtomPipeline = class {
     };
   }
 };
-function extractMigrationFacts(content) {
+function extractRuleBasedFacts(content, type2) {
   const facts = [];
-  const fromToPattern = /\bfrom\s+[A-Za-z0-9][A-Za-z0-9._]*(?:\s+[A-Za-z0-9._]+)*\s+to\b/gi;
-  if (fromToPattern.test(content)) {
-    const cleaned = content.replace(fromToPattern, "to").replace(/\s+/g, " ").trim();
-    if (cleaned !== content && cleaned.length > 10) {
-      facts.push({ text: cleaned, confidence: 0.85 });
+  const text = content.trim();
+  if (type2 === "decision") {
+    const decisionMatch = text.match(/^Decision:\s*(.+)/i);
+    if (decisionMatch) {
+      const fact = decisionMatch[1].trim();
+      if (fact.length > 10) facts.push({ text: fact, confidence: 0.9 });
+    }
+    const choseMatch = text.match(/chose\s+(.+?)\s+over\s+/i);
+    if (choseMatch) {
+      const fact = `Use ${choseMatch[1].trim()}`;
+      if (fact.length > 10) facts.push({ text: fact, confidence: 0.85 });
+    }
+    const useMatch = text.match(/use\s+\S+\s+for\s+\S+/i);
+    if (useMatch && facts.length < 3) {
+      const fact = text.slice(useMatch.index, useMatch.index + useMatch[0].length);
+      if (fact.length > 10) facts.push({ text: fact, confidence: 0.8 });
+    }
+  } else if (type2 === "learning") {
+    const firstSentence = text.split(/[.!?]/)[0].trim();
+    if (firstSentence.length > 15 && firstSentence.length < 200) {
+      facts.push({ text: firstSentence, confidence: 0.8 });
+    }
+  } else if (type2 === "error") {
+    const cmdMatch = text.match(/Command failed:\s*(.+)/i);
+    if (cmdMatch) {
+      const cmd = cmdMatch[1].trim().slice(0, 100);
+      facts.push({ text: `Error: ${cmd} fails`, confidence: 0.85 });
+    }
+    const exitMatch = text.match(/Exit code\s+(\d+)/i);
+    if (exitMatch && facts.length < 3) {
+      facts.push({ text: `Exit code ${exitMatch[1]}`, confidence: 0.7 });
+    }
+  } else if (type2 === "conversation") {
+    const fromToPattern = /\bfrom\s+[A-Za-z0-9][A-Za-z0-9._]*(?:\s+[A-Za-z0-9._]+)*\s+to\b/gi;
+    if (fromToPattern.test(text)) {
+      const cleaned = text.replace(fromToPattern, "to").replace(/\s+/g, " ").trim();
+      if (cleaned !== text && cleaned.length > 10) {
+        facts.push({ text: cleaned, confidence: 0.85 });
+      }
     }
   }
-  return facts;
+  return facts.slice(0, 3);
 }
 function parseFacts(response, sourceId) {
   const lines = response.trim().split("\n");
@@ -972,17 +1098,25 @@ var OpenAILLMClient = class {
 // src/cli/extract.ts
 async function extractCommand(dbPath, flags) {
   const apiKey = process.env.REMEM_LLM_API_KEY ?? process.env.OPENAI_API_KEY;
-  if (!apiKey) {
-    console.error("Error: Set REMEM_LLM_API_KEY (or OPENAI_API_KEY) to run atom extraction.");
-    process.exit(1);
-  }
-  const baseUrl = process.env.REMEM_LLM_BASE_URL ?? "https://api.openai.com/v1";
-  const model = process.env.REMEM_LLM_MODEL ?? "gpt-4o-mini";
+  const useLLM = flags.llm !== void 0 && apiKey;
   const storage = new SQLiteBackend(dbPath);
   try {
     const embedder = new LocalEmbedder();
-    const pipeline = new AtomPipeline();
-    const llmClient = new OpenAILLMClient({ apiKey, baseUrl, model });
+    let pipeline;
+    let llmClient = null;
+    if (useLLM) {
+      const baseUrl = process.env.REMEM_LLM_BASE_URL ?? "https://api.openai.com/v1";
+      const model = process.env.REMEM_LLM_MODEL ?? "gpt-4o-mini";
+      pipeline = new AtomPipeline();
+      llmClient = new OpenAILLMClient({ apiKey, baseUrl, model });
+      console.log("Mode: LLM-based extraction (gpt-4o-mini)");
+    } else {
+      pipeline = new RuleBasedAtomPipeline();
+      console.log("Mode: rule-based extraction (no LLM, zero cost)");
+      if (flags.llm !== void 0 && !apiKey) {
+        console.log("  (--llm requested but no API key found, falling back to rule-based)");
+      }
+    }
     const limit = flags.limit ? Number(flags.limit) : 50;
     const captureId = flags["capture-id"];
     let captures;
@@ -990,29 +1124,31 @@ async function extractCommand(dbPath, flags) {
       const entry = await storage.get(captureId);
       captures = entry ? [entry] : [];
     } else {
-      const results = await storage.search("", null, {
-        limit,
-        offset: 0,
-        mode: "keyword",
-        filters: flags["team-id"] ? { teamId: flags["team-id"] } : void 0
-      });
-      captures = results.map((r) => r.entry).filter((e) => ["decision", "learning", "error"].includes(e.type));
+      const allCaptures = await storage.listAll(limit, 0);
+      captures = allCaptures.filter((e) => ["decision", "learning", "error", "conversation"].includes(e.type));
     }
     if (captures.length === 0) {
       console.log("No captures to extract atoms from.");
       return;
     }
-    console.log(`Extracting atoms from ${captures.length} capture(s)...`);
+    console.log(`Extracting atoms from ${captures.length} capture(s)...
+`);
     const ctx = {
-      llmClient,
+      llmClient: llmClient ?? void 0,
       storage,
       embedder,
       sessionKey: ""
     };
     let totalAtoms = 0;
     let errors2 = 0;
+    let skipped = 0;
     for (const capture of captures) {
       try {
+        const existing = await storage.listAtoms({ captureId: capture.id, limit: 1 });
+        if (existing.length > 0) {
+          skipped++;
+          continue;
+        }
         const output2 = await pipeline.process(
           {
             id: capture.id,
@@ -1028,17 +1164,21 @@ async function extractCommand(dbPath, flags) {
         );
         const atomCount = output2.atoms?.length ?? 0;
         totalAtoms += atomCount;
-        console.log(`  ${capture.id}: ${atomCount} atom(s)`);
+        if (atomCount > 0) {
+          console.log(`  [${capture.type}] ${capture.id}: ${atomCount} atom(s)`);
+          for (const a of output2.atoms ?? []) {
+            console.log(`    \u2192 ${a.fact.slice(0, 80)}`);
+          }
+        }
       } catch (err) {
         errors2++;
         console.error(`  ${capture.id}: FAILED \u2014 ${err}`);
       }
     }
     console.log(`
-Done. Extracted ${totalAtoms} atom(s) from ${captures.length} capture(s).`);
-    if (errors2 > 0) {
-      console.log(`${errors2} capture(s) failed.`);
-    }
+Done. Extracted ${totalAtoms} atom(s) from ${captures.length - skipped} capture(s).`);
+    if (skipped > 0) console.log(`${skipped} capture(s) already had atoms (skipped).`);
+    if (errors2 > 0) console.log(`${errors2} capture(s) failed.`);
   } finally {
     storage.close();
   }
@@ -1046,6 +1186,7 @@ Done. Extracted ${totalAtoms} atom(s) from ${captures.length} capture(s).`);
 
 // src/cli/knowledge.ts
 init_esm_shims();
+init_ulid();
 async function knowledgeCommand(dbPath, flags) {
   const storage = new SQLiteBackend(dbPath);
   try {
@@ -1102,28 +1243,55 @@ async function knowledgeCommand(dbPath, flags) {
 
 // src/cli/persona.ts
 init_esm_shims();
+import Database3 from "better-sqlite3";
 async function personaCommand(dbPath, flags) {
-  const teamId = flags["team-id"];
-  const agentId = flags["agent-id"];
-  const userId = flags["user-id"];
-  if (!teamId || !agentId || !userId) {
-    console.error("Error: --team-id, --agent-id, and --user-id are required.");
-    process.exit(1);
-  }
   const storage = new SQLiteBackend(dbPath);
   try {
-    if (flags.write) {
-      await storage.writePersona(teamId, agentId, userId, flags.write);
-      console.log(`Persona written for team=${teamId} agent=${agentId} user=${userId}.`);
+    const teamId = flags["team-id"] ?? "default";
+    const agentId = flags["agent-id"] ?? "unknown";
+    const userId = flags["user-id"] ?? "default";
+    if (flags.clear !== void 0) {
+      await storage.writePersona(teamId, agentId, userId, "");
+      console.log("Persona cleared.");
       return;
     }
-    const persona = await storage.readPersona(teamId, agentId, userId);
-    if (!persona) {
-      console.log("No persona found. Use --write <content> to create one.");
+    if (flags.set) {
+      const existing = await storage.readPersona(teamId, agentId, userId);
+      const entry = flags.set;
+      const [trait] = entry.split(":");
+      let content;
+      if (existing && existing.content) {
+        const lines = existing.content.split("\n").filter((l) => l.trim());
+        const traitPattern = new RegExp(
+          `^${trait.trim().replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}:`,
+          "i"
+        );
+        const idx = lines.findIndex((l) => traitPattern.test(l));
+        if (idx >= 0) {
+          lines[idx] = entry;
+        } else {
+          lines.push(entry);
+        }
+        content = lines.join("\n");
+      } else {
+        content = entry;
+      }
+      await storage.writePersona(teamId, agentId, userId, content);
+      console.log(`Persona updated: ${entry}`);
       return;
     }
-    console.log(`Persona (updated ${new Date(persona.updatedAt).toISOString()}):`);
-    console.log(persona.content);
+    const db = new Database3(dbPath, { readonly: true });
+    try {
+      const row = db.prepare("SELECT content FROM persona WHERE team_id = ? AND user_id = ? ORDER BY updated_at DESC LIMIT 1").get(teamId, userId);
+      if (!row || !row.content) {
+        console.log('No persona set. Use --set "trait: value" to add one.');
+        return;
+      }
+      console.log("Persona (L3):");
+      console.log(row.content);
+    } finally {
+      db.close();
+    }
   } finally {
     storage.close();
   }
@@ -1206,7 +1374,7 @@ init_esm_shims();
 import { existsSync as existsSync4, statSync } from "fs";
 import { homedir as homedir2 } from "os";
 import { join as join4 } from "path";
-import Database3 from "better-sqlite3";
+import Database4 from "better-sqlite3";
 function defaultDbPath() {
   return process.env.REMEM_DB_PATH ?? join4(homedir2(), ".local", "share", "remem-mcp", "memory.db");
 }
@@ -1229,7 +1397,7 @@ function status(dbPath = defaultDbPath()) {
   }
   let db;
   try {
-    db = new Database3(dbPath, { readonly: true });
+    db = new Database4(dbPath, { readonly: true });
   } catch {
     console.error("  \u2717 Could not open database.");
     console.log(bar + "\n");
@@ -1308,6 +1476,151 @@ Memory:  ${total.c} captures across ${sessions.c} project(s)`);
   db.close();
 }
 
+// src/cli/worker.ts
+init_esm_shims();
+init_local();
+
+// src/pipeline/worker.ts
+init_esm_shims();
+init_ulid();
+async function runPipelineWorker(opts, embedder) {
+  const storage = new SQLiteBackend(opts.dbPath);
+  const result = {
+    capturesProcessed: 0,
+    atomsExtracted: 0,
+    scenariosCreated: 0,
+    personaUpdated: false,
+    errors: []
+  };
+  try {
+    const teamId = opts.teamId ?? "default";
+    const userId = opts.userId ?? "default";
+    const batchSize = opts.batchSize ?? 50;
+    const consolidateThreshold = opts.consolidateThreshold ?? 5;
+    const personaThreshold = opts.personaThreshold ?? 2;
+    const pipeline = new RuleBasedAtomPipeline();
+    const ctx = {
+      storage,
+      embedder,
+      sessionKey: "worker"
+    };
+    const db = storage.db;
+    const captures = db.prepare(
+      `SELECT id, content, type, tags, session_key, team_id, user_id, created_at
+         FROM captures
+         WHERE (team_id = ? OR team_id IS NULL OR team_id = 'default')
+           AND id NOT IN (SELECT DISTINCT capture_id FROM atoms)
+         ORDER BY created_at DESC
+         LIMIT ?`
+    ).all(teamId, batchSize);
+    for (const cap of captures) {
+      try {
+        const input = {
+          id: cap.id,
+          content: cap.content,
+          type: cap.type,
+          tags: cap.tags ? JSON.parse(cap.tags) : [],
+          sessionKey: cap.session_key,
+          teamId: cap.team_id,
+          userId: cap.user_id ?? void 0
+        };
+        const output2 = await pipeline.process(input, ctx);
+        if (output2.atoms) {
+          result.atomsExtracted += output2.atoms.length;
+        }
+        result.capturesProcessed++;
+      } catch (err) {
+        result.errors.push(`capture ${cap.id}: ${err}`);
+      }
+    }
+    const atoms = await storage.listAtoms({ limit: 200 });
+    const groups = /* @__PURE__ */ new Map();
+    for (const a of atoms) {
+      const words = a.fact.toLowerCase().split(/[^a-z0-9]+/).filter((w) => w.length > 3);
+      const key = words.slice(0, 2).join("-") || "misc";
+      if (!groups.has(key)) groups.set(key, []);
+      groups.get(key).push(a);
+    }
+    const existingScenarios = await storage.listScenarios({ limit: 100 });
+    const existingTopics = new Set(
+      existingScenarios.flatMap((s) => s.personaTags ?? [])
+    );
+    for (const [topic, groupAtoms] of groups) {
+      if (groupAtoms.length < consolidateThreshold) continue;
+      if (existingTopics.has(topic)) continue;
+      const summary = groupAtoms.slice(0, 5).map((a) => a.fact).join("; ");
+      const id = generateId();
+      await storage.putScenario({
+        id,
+        atomIds: groupAtoms.map((a) => a.id),
+        summary: summary.slice(0, 300),
+        personaTags: [topic],
+        createdAt: Date.now()
+      });
+      result.scenariosCreated++;
+    }
+    const tagCounts = db.prepare(
+      `SELECT tags FROM captures
+         WHERE (team_id = ? OR team_id IS NULL OR team_id = 'default')
+         ORDER BY created_at DESC LIMIT 100`
+    ).all(teamId);
+    const tagFreq = /* @__PURE__ */ new Map();
+    for (const row of tagCounts) {
+      if (!row.tags) continue;
+      try {
+        const tags = JSON.parse(row.tags);
+        for (const t of tags) {
+          tagFreq.set(t, (tagFreq.get(t) ?? 0) + 1);
+        }
+      } catch {
+      }
+    }
+    const existingPersonaRow = db.prepare(
+      "SELECT content FROM persona WHERE team_id = ? AND user_id = ? ORDER BY updated_at DESC LIMIT 1"
+    ).get(teamId, userId);
+    const existingContent = existingPersonaRow?.content ?? "";
+    const repeatedTags = Array.from(tagFreq.entries()).filter(([tag, count]) => count >= personaThreshold && !existingContent.includes(tag)).sort((a, b) => b[1] - a[1]).slice(0, 3);
+    if (repeatedTags.length > 0) {
+      const newTraits = repeatedTags.map(([tag, count]) => `${tag}: ${count} occurrences`);
+      const updatedContent = existingContent ? `${existingContent}
+${newTraits.join("\n")}` : newTraits.join("\n");
+      await storage.writePersona(teamId, "default", userId, updatedContent);
+      result.personaUpdated = true;
+    }
+  } finally {
+    storage.close();
+  }
+  return result;
+}
+
+// src/cli/worker.ts
+async function workerCommand(dbPath, flags) {
+  const embedder = new LocalEmbedder();
+  const result = await runPipelineWorker(
+    {
+      dbPath,
+      batchSize: flags["batch-size"] ? Number(flags["batch-size"]) : 50,
+      teamId: flags["team-id"],
+      userId: flags["user-id"]
+    },
+    embedder
+  );
+  console.log("Pipeline worker results:");
+  console.log(`  Captures processed (L0\u2192L1): ${result.capturesProcessed}`);
+  console.log(`  Atoms extracted:            ${result.atomsExtracted}`);
+  console.log(`  Scenarios created (L1\u2192L2):  ${result.scenariosCreated}`);
+  console.log(`  Persona updated (L2\u2192L3):    ${result.personaUpdated ? "yes" : "no"}`);
+  if (result.errors.length > 0) {
+    console.log(`  Errors:                     ${result.errors.length}`);
+    for (const e of result.errors.slice(0, 5)) {
+      console.log(`    - ${e}`);
+    }
+  }
+}
+
+// src/index.ts
+init_engine();
+
 // src/config.ts
 init_esm_shims();
 import { existsSync as existsSync5, readFileSync as readFileSync3 } from "fs";
@@ -1422,7 +1735,14 @@ function checkHooksConfig(name, path) {
       (h) => h.hooks?.some((hook) => hook.command?.includes("remem-mcp"))
     );
     const required = ["SessionStart", "Stop"];
-    const optional = ["PreToolUse", "PostToolUse", "SessionEnd", "PreCompact", "PostCompaction"];
+    const optional = [
+      "PreToolUse",
+      "PostToolUse",
+      "SessionEnd",
+      "PreCompact",
+      "PostCompact",
+      "PostCompaction"
+    ];
     const missing = required.filter((ev) => !hasTdai(ev));
     const presentOptional = optional.filter((ev) => hasTdai(ev));
     if (missing.length > 0) {
@@ -1532,14 +1852,14 @@ init_local();
 init_esm_shims();
 import { homedir as homedir5 } from "os";
 import { join as join7 } from "path";
-import Database4 from "better-sqlite3";
+import Database5 from "better-sqlite3";
 function defaultDbPath2() {
   return process.env.REMEM_DB_PATH ?? join7(homedir5(), ".local", "share", "remem-mcp", "memory.db");
 }
 function errors(dbPath = defaultDbPath2()) {
   let db;
   try {
-    db = new Database4(dbPath, { readonly: true });
+    db = new Database5(dbPath, { readonly: true });
   } catch {
     console.error("Error: Could not open database at", dbPath);
     process.exit(1);
@@ -1658,7 +1978,7 @@ function errors(dbPath = defaultDbPath2()) {
 function errorsRetro(dbPath = defaultDbPath2()) {
   let db;
   try {
-    db = new Database4(dbPath, { readonly: true });
+    db = new Database5(dbPath, { readonly: true });
   } catch {
     console.error("Error: Could not open database at", dbPath);
     process.exit(1);
@@ -2013,7 +2333,7 @@ function errorsRetro(dbPath = defaultDbPath2()) {
 function errorsDrift(dbPath = defaultDbPath2()) {
   let db;
   try {
-    db = new Database4(dbPath, { readonly: true });
+    db = new Database5(dbPath, { readonly: true });
   } catch {
     console.error("Error: Could not open database at", dbPath);
     process.exit(1);
@@ -2124,7 +2444,7 @@ function errorsDrift(dbPath = defaultDbPath2()) {
 function errorsLineage(dbPath = defaultDbPath2()) {
   let db;
   try {
-    db = new Database4(dbPath, { readonly: true });
+    db = new Database5(dbPath, { readonly: true });
   } catch {
     console.error("Error: Could not open database at", dbPath);
     process.exit(1);
@@ -2293,7 +2613,7 @@ function errorsLineage(dbPath = defaultDbPath2()) {
 function errorsByGoal(dbPath = defaultDbPath2()) {
   let db;
   try {
-    db = new Database4(dbPath, { readonly: true });
+    db = new Database5(dbPath, { readonly: true });
   } catch {
     console.error("Error: Could not open database at", dbPath);
     process.exit(1);
@@ -2350,7 +2670,7 @@ function errorsByGoal(dbPath = defaultDbPath2()) {
 function errorsActions(dbPath = defaultDbPath2()) {
   let db;
   try {
-    db = new Database4(dbPath, { readonly: true });
+    db = new Database5(dbPath, { readonly: true });
   } catch {
     console.error("Error: Could not open database at", dbPath);
     process.exit(1);
@@ -2471,7 +2791,7 @@ function errorsActions(dbPath = defaultDbPath2()) {
 function errorsSeverity(dbPath = defaultDbPath2()) {
   let db;
   try {
-    db = new Database4(dbPath, { readonly: true });
+    db = new Database5(dbPath, { readonly: true });
   } catch {
     console.error("Error: Could not open database at", dbPath);
     process.exit(1);
@@ -2582,7 +2902,7 @@ function errorsSeverity(dbPath = defaultDbPath2()) {
 function errorsTemplates(dbPath = defaultDbPath2()) {
   let db;
   try {
-    db = new Database4(dbPath, { readonly: true });
+    db = new Database5(dbPath, { readonly: true });
   } catch {
     console.error("Error: Could not open database at", dbPath);
     process.exit(1);
@@ -2654,7 +2974,7 @@ function errorsTemplates(dbPath = defaultDbPath2()) {
 function errorsCorrelations(dbPath = defaultDbPath2()) {
   let db;
   try {
-    db = new Database4(dbPath, { readonly: true });
+    db = new Database5(dbPath, { readonly: true });
   } catch {
     console.error("Error: Could not open database at", dbPath);
     process.exit(1);
@@ -2735,7 +3055,7 @@ function errorsCorrelations(dbPath = defaultDbPath2()) {
 function errorsPlaybooks(dbPath = defaultDbPath2()) {
   let db;
   try {
-    db = new Database4(dbPath, { readonly: true });
+    db = new Database5(dbPath, { readonly: true });
   } catch {
     console.error("Error: Could not open database at", dbPath);
     process.exit(1);
@@ -2803,7 +3123,7 @@ function errorsPlaybooks(dbPath = defaultDbPath2()) {
 function errorsStale(dbPath = defaultDbPath2()) {
   let db;
   try {
-    db = new Database4(dbPath, { readonly: true });
+    db = new Database5(dbPath, { readonly: true });
   } catch {
     console.error("Error: Could not open database at", dbPath);
     process.exit(1);
@@ -2881,7 +3201,7 @@ function errorsStale(dbPath = defaultDbPath2()) {
 function errorsEscalations(dbPath = defaultDbPath2()) {
   let db;
   try {
-    db = new Database4(dbPath, { readonly: true });
+    db = new Database5(dbPath, { readonly: true });
   } catch {
     console.error("Error: Could not open database at", dbPath);
     process.exit(1);
@@ -2975,7 +3295,7 @@ function errorsEscalations(dbPath = defaultDbPath2()) {
 function errorsContext(dbPath = defaultDbPath2()) {
   let db;
   try {
-    db = new Database4(dbPath, { readonly: true });
+    db = new Database5(dbPath, { readonly: true });
   } catch {
     console.error("Error: Could not open database at", dbPath);
     process.exit(1);
@@ -3049,7 +3369,7 @@ function errorsContext(dbPath = defaultDbPath2()) {
 function errorsInherited(dbPath = defaultDbPath2()) {
   let db;
   try {
-    db = new Database4(dbPath, { readonly: true });
+    db = new Database5(dbPath, { readonly: true });
   } catch {
     console.error("Error: Could not open database at", dbPath);
     process.exit(1);
@@ -3122,7 +3442,7 @@ function errorsInherited(dbPath = defaultDbPath2()) {
 function errorsProvenance(dbPath = defaultDbPath2()) {
   let db;
   try {
-    db = new Database4(dbPath, { readonly: true });
+    db = new Database5(dbPath, { readonly: true });
   } catch {
     console.error("Error: Could not open database at", dbPath);
     process.exit(1);
@@ -3198,7 +3518,7 @@ function errorsProvenance(dbPath = defaultDbPath2()) {
 function errorsPersona(dbPath = defaultDbPath2()) {
   let db;
   try {
-    db = new Database4(dbPath, { readonly: true });
+    db = new Database5(dbPath, { readonly: true });
   } catch {
     console.error("Error: Could not open database at", dbPath);
     process.exit(1);
@@ -3318,7 +3638,7 @@ function errorsPersona(dbPath = defaultDbPath2()) {
 function decisionsDashboard(dbPath = defaultDbPath2()) {
   let db;
   try {
-    db = new Database4(dbPath, { readonly: true });
+    db = new Database5(dbPath, { readonly: true });
   } catch {
     console.error("Error: Could not open database at", dbPath);
     process.exit(1);
@@ -3385,7 +3705,7 @@ ${"\u2500".repeat(60)}`);
 function decisionsRetro(dbPath = defaultDbPath2()) {
   let db;
   try {
-    db = new Database4(dbPath, { readonly: true });
+    db = new Database5(dbPath, { readonly: true });
   } catch {
     console.error("Error: Could not open database at", dbPath);
     process.exit(1);
@@ -3446,7 +3766,7 @@ function decisionsRetro(dbPath = defaultDbPath2()) {
 function patternsDashboard(dbPath = defaultDbPath2()) {
   let db;
   try {
-    db = new Database4(dbPath, { readonly: true });
+    db = new Database5(dbPath, { readonly: true });
   } catch {
     console.error("Error: Could not open database at", dbPath);
     process.exit(1);
@@ -3521,7 +3841,7 @@ ${"\u2500".repeat(60)}`);
 function patternsRetro(dbPath = defaultDbPath2()) {
   let db;
   try {
-    db = new Database4(dbPath, { readonly: true });
+    db = new Database5(dbPath, { readonly: true });
   } catch {
     console.error("Error: Could not open database at", dbPath);
     process.exit(1);
@@ -3575,7 +3895,7 @@ function patternsRetro(dbPath = defaultDbPath2()) {
 function decisionsConflicts(dbPath = defaultDbPath2()) {
   let db;
   try {
-    db = new Database4(dbPath, { readonly: true });
+    db = new Database5(dbPath, { readonly: true });
   } catch {
     console.error("Error: Could not open database at", dbPath);
     process.exit(1);
@@ -3619,7 +3939,7 @@ ${"\u2500".repeat(60)}`);
 function decisionsInherited(dbPath = defaultDbPath2()) {
   let db;
   try {
-    db = new Database4(dbPath, { readonly: true });
+    db = new Database5(dbPath, { readonly: true });
   } catch {
     console.error("Error: Could not open database at", dbPath);
     process.exit(1);
@@ -3662,7 +3982,7 @@ ${"\u2500".repeat(60)}`);
 function patternsConflicts(dbPath = defaultDbPath2()) {
   let db;
   try {
-    db = new Database4(dbPath, { readonly: true });
+    db = new Database5(dbPath, { readonly: true });
   } catch {
     console.error("Error: Could not open database at", dbPath);
     process.exit(1);
@@ -3707,7 +4027,7 @@ ${"\u2500".repeat(60)}`);
 function patternsTemplates(dbPath = defaultDbPath2()) {
   let db;
   try {
-    db = new Database4(dbPath, { readonly: true });
+    db = new Database5(dbPath, { readonly: true });
   } catch {
     console.error("Error: Could not open database at", dbPath);
     process.exit(1);
@@ -3759,7 +4079,7 @@ ${"\u2500".repeat(60)}`);
 function patternsInherited(dbPath = defaultDbPath2()) {
   let db;
   try {
-    db = new Database4(dbPath, { readonly: true });
+    db = new Database5(dbPath, { readonly: true });
   } catch {
     console.error("Error: Could not open database at", dbPath);
     process.exit(1);
@@ -3806,9 +4126,9 @@ ${"\u2500".repeat(60)}`);
 // src/export.ts
 init_esm_shims();
 import { writeFileSync as writeFileSync2 } from "fs";
-import Database5 from "better-sqlite3";
+import Database6 from "better-sqlite3";
 function exportData(dbPath, outputPath, filters) {
-  const db = new Database5(dbPath, { readonly: true });
+  const db = new Database6(dbPath, { readonly: true });
   let sql = "SELECT * FROM captures";
   const params = [];
   const conditions = [];
@@ -3855,7 +4175,7 @@ function exportData(dbPath, outputPath, filters) {
 // src/export-md.ts
 init_esm_shims();
 import { writeFileSync as writeFileSync3 } from "fs";
-import Database6 from "better-sqlite3";
+import Database7 from "better-sqlite3";
 var TYPE_ORDER = ["learning", "decision", "error", "task", "conversation", "atom", "pattern"];
 function escapeMd(text) {
   return text.replace(/\n{3,}/g, "\n\n");
@@ -3873,7 +4193,7 @@ function parseTags(raw) {
   }
 }
 function exportMarkdown(dbPath, outputPath, filters) {
-  const db = new Database6(dbPath, { readonly: true });
+  const db = new Database7(dbPath, { readonly: true });
   let sql = "SELECT id, session_key, agent_id, type, content, tags, created_at, trust_state FROM captures WHERE deleted_at IS NULL";
   const params = [];
   const conditions = [];
@@ -3956,7 +4276,7 @@ import { createHash as createHash3 } from "crypto";
 import { appendFileSync as appendFileSync2, existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
 import { homedir as homedir6, tmpdir as tmpdir2 } from "os";
 import { dirname as dirname4, join as join8 } from "path";
-import Database7 from "better-sqlite3";
+import Database8 from "better-sqlite3";
 var SHOW_FEEDBACK = process.env.REMEM_QUIET !== "1";
 function feedback(emoji, message) {
   if (SHOW_FEEDBACK) {
@@ -4225,9 +4545,9 @@ function hookRecall(dbPath) {
       const autoCaptureKey = input.session_id ? input.session_id.slice(0, 16) : void 0;
       let db;
       try {
-        db = new Database7(dbPath, { readonly: true, immutable: true });
+        db = new Database8(dbPath, { readonly: true, immutable: true });
       } catch {
-        db = new Database7(dbPath, { readonly: true });
+        db = new Database8(dbPath, { readonly: true });
       }
       const errorSql = `
         SELECT id, type, content, tags, created_at
@@ -4260,8 +4580,8 @@ function hookRecall(dbPath) {
           rows.push(...autoOthers.filter((r) => !seen.has(r.id)));
         }
       }
-      db.close();
       if (rows.length === 0) {
+        db.close();
         logToFile("SessionStart: no recent memory found");
         process.stdout.write(JSON.stringify({}));
         return;
@@ -4274,6 +4594,34 @@ function hookRecall(dbPath) {
         const content = row.content.length > 200 ? `${row.content.slice(0, 200)}...` : row.content;
         lines.push(`- (${row.type}${tagStr}) ${date}: ${content}`);
       }
+      try {
+        const personaRow = db.prepare("SELECT content FROM persona WHERE team_id = ? AND user_id = ? ORDER BY updated_at DESC LIMIT 1").get("default", "default");
+        if (personaRow && personaRow.content) {
+          lines.push("");
+          lines.push(`## Persona (L3)`);
+          lines.push(personaRow.content);
+        }
+      } catch {
+      }
+      try {
+        const scenarios = db.prepare("SELECT summary FROM scenarios ORDER BY created_at DESC LIMIT 3").all();
+        if (scenarios.length > 0) {
+          lines.push("");
+          lines.push(`## Scenarios (L2)`);
+          for (const s of scenarios) lines.push(`- ${s.summary}`);
+        }
+      } catch {
+      }
+      try {
+        const skills = db.prepare("SELECT name, description FROM skills ORDER BY updated_at DESC LIMIT 3").all();
+        if (skills.length > 0) {
+          lines.push("");
+          lines.push(`## Skills`);
+          for (const s of skills) lines.push(`- ${s.name}: ${(s.description || "").slice(0, 80)}`);
+        }
+      } catch {
+      }
+      db.close();
       lines.push("");
       lines.push("Use these memories to inform your work. Call recall() for more details.");
       lines.push(
@@ -4303,6 +4651,266 @@ ${context}`);
     }
   });
 }
+function isAckPrompt(prompt2) {
+  const p = prompt2.toLowerCase().trim();
+  if (p.length < 5) return true;
+  const ackPatterns = /^(ok|okay|k|yes|no|yep|nope|thanks|thank you|cool|nice|great|done|got it|understood|continue|go|next|tiếp|tiếp đi|xong|ok rồi|được rồi|đúng|sai|uh|uhm|ừm|👍|✅|❌)\b/i;
+  return ackPatterns.test(p);
+}
+function extractUpdateFact(prompt2) {
+  const p = prompt2.trim();
+  if (p.length < 15) return null;
+  const updatePatterns = [
+    // "remember that ..." / "nhớ là ..." / "đừng quên ..."
+    { re: /^(?:remember that|remember|don't forget|dont forget|note that|for future reference)\s*:?\s*(.+)/i, type: "learning" },
+    { re: /^(?:nhớ là|nhớ rằng|đừng quên|ghi nhớ)\s*:?\s*(.+)/i, type: "learning" },
+    // "we use/chose/decided ..." / "mình dùng/chọn/quyết định ..."
+    { re: /^(?:we use|we chose|we decided|we prefer|we always|our convention|our standard)\s*:?\s*(.+)/i, type: "decision" },
+    { re: /^(?:mình dùng|mình chọn|mình quyết định|chúng ta dùng|chúng ta chọn)\s*:?\s*(.+)/i, type: "decision" },
+    // "update X to Y" / "change X to Y" / "sửa X thành Y"
+    { re: /^(?:update|change|set|configure)\s+.+\s+(?:to|as|=\s*)\s*(.+)/i, type: "decision" },
+    { re: /^(?:sửa|đổi|cập nhật)\s+.+\s+(?:thành|sang|=\s*)\s*(.+)/i, type: "decision" },
+    // "actually ..." / "no, it's ..." / "không, là ..." (correction)
+    { re: /^(?:actually|no,?\s*(?:it's|it is|the|this)?\s*:?\s*)(.+)/i, type: "learning" },
+    { re: /^(?:không,?\s*(?:là|nó là|thực ra)?\s*:?\s*)(.+)/i, type: "learning" },
+    // "the port/config/X is Y" / "port là Y" (direct fact statement)
+    { re: /^(?:the\s+)?(\w+\s+(?:is|are|was|should be|must be)\s+.+)/i, type: "learning" },
+    { re: /^(\w+\s+(?:là|phải là|nên là)\s+.+)/i, type: "learning" }
+  ];
+  for (const { re, type: type2 } of updatePatterns) {
+    const match = re.exec(p);
+    if (match) {
+      const fact = match[1]?.trim();
+      if (!fact || fact.length < 10) return null;
+      if (fact.endsWith("?") || fact.endsWith("??")) return null;
+      if (fact.split(/\s+/).length < 2) return null;
+      return { fact, type: type2 };
+    }
+  }
+  return null;
+}
+function hookUserPromptSubmit(dbPath) {
+  const chunks = [];
+  process.stdin.setEncoding("utf-8");
+  process.stdin.on("error", () => process.stdout.write(JSON.stringify({})));
+  const stdinTimeout = setTimeout(() => process.stdout.write(JSON.stringify({})), 5e3);
+  stdinTimeout.unref();
+  process.stdin.on("data", (chunk) => {
+    chunks.push(Buffer.from(chunk));
+  });
+  process.stdin.on("end", () => {
+    clearTimeout(stdinTimeout);
+    try {
+      const raw = Buffer.concat(chunks).toString("utf-8");
+      if (!raw.trim()) {
+        process.stdout.write(JSON.stringify({}));
+        return;
+      }
+      const input = JSON.parse(raw);
+      const prompt2 = input.prompt ?? input.user_prompt ?? input.message ?? "";
+      if (!prompt2) {
+        process.stdout.write(JSON.stringify({}));
+        return;
+      }
+      const cwd = input.cwd ?? process.cwd();
+      const sessionKey = hashPath(cwd);
+      const isAck = isAckPrompt(prompt2);
+      const updateFact = isAck ? null : extractUpdateFact(prompt2);
+      if (isAck) {
+        const output2 = {
+          hookSpecificOutput: {
+            hookEventName: "UserPromptSubmit",
+            additionalContext: "[remem-mcp] recall() is available \u2014 call it if you need past project context."
+          }
+        };
+        process.stdout.write(JSON.stringify(output2));
+        return;
+      }
+      let db;
+      try {
+        db = new Database8(dbPath);
+      } catch {
+        try {
+          db = new Database8(dbPath, { readonly: true });
+        } catch {
+          process.stdout.write(JSON.stringify({}));
+          return;
+        }
+      }
+      let captured = false;
+      if (updateFact) {
+        try {
+          const content = updateFact.type === "decision" ? `Decision: ${updateFact.fact}` : updateFact.fact;
+          const contentHash = createHash3("sha256").update(content).digest("hex").slice(0, 16);
+          const existing = db.prepare("SELECT id FROM captures WHERE content_hash = ? AND deleted_at IS NULL").get(contentHash);
+          if (existing) {
+            logToFile(`UserPromptSubmit: duplicate fact (hash match), skipping capture`);
+          } else {
+            const id = generateId2();
+            const now = Date.now();
+            db.prepare(
+              "INSERT INTO captures (id, session_key, agent_id, type, content, content_hash, tags, created_at, metadata) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)"
+            ).run(
+              id,
+              sessionKey,
+              "user-prompt",
+              updateFact.type,
+              content,
+              contentHash,
+              JSON.stringify(["auto-capture", "user-prompt"]),
+              now,
+              JSON.stringify({
+                source: "UserPromptSubmit",
+                captured_from: prompt2.slice(0, 200)
+              })
+            );
+            captured = true;
+            logToFile(
+              `UserPromptSubmit: captured ${updateFact.type}: ${updateFact.fact.slice(0, 80)}`
+            );
+            feedback("\u{1F4DD}", `remem-mcp: saved ${updateFact.type} from your prompt`);
+          }
+        } catch (capErr) {
+          logToFile(`UserPromptSubmit: capture error - ${capErr}`);
+        }
+      }
+      let recallContext = "";
+      {
+        const sql = `
+          SELECT fts.id as id, bm25(captures_fts) as score,
+                 c.type as type, c.content as content, c.tags as tags,
+                 c.created_at as created_at
+          FROM captures_fts fts
+          JOIN captures c ON c.id = fts.id
+          WHERE captures_fts MATCH ?
+            AND c.deleted_at IS NULL
+            AND c.trust_state <> 'rejected'
+            AND c.superseded_by IS NULL
+            AND c.session_key = ?
+            AND c.type IN ('error', 'decision', 'learning', 'task')
+          ORDER BY score
+          LIMIT 5
+        `;
+        const keywords = prompt2.toLowerCase().split(/[^a-z0-9_]+/i).filter((w) => w.length >= 3).slice(0, 8).map((w) => w.replace(/["'*:()]/g, ""));
+        if (keywords.length > 0) {
+          const ftsQuery = keywords.map((w) => `"${w}"`).join(" OR ");
+          let rows = [];
+          try {
+            rows = db.prepare(sql).all(ftsQuery, sessionKey);
+          } catch {
+          }
+          const globalKey = process.env.REMEM_GLOBAL_SESSION_KEY;
+          if (globalKey && globalKey !== sessionKey) {
+            try {
+              const globalRows = db.prepare(sql).all(ftsQuery, globalKey);
+              const seen = new Set(rows.map((r) => r.id));
+              rows.push(...globalRows.filter((r) => !seen.has(r.id)).slice(0, 2));
+            } catch {
+            }
+          }
+          if (rows.length > 0) {
+            const lines = [`[remem-mcp] Memory relevant to your prompt (BM25, shallow):`];
+            for (const row of rows.slice(0, 5)) {
+              const date = new Date(row.created_at).toISOString().split("T")[0];
+              const tags = safeParseTags(row.tags);
+              const tagStr = tags.length > 0 ? ` [${tags.join(", ")}]` : "";
+              const content = row.content.length > 200 ? `${row.content.slice(0, 200)}...` : row.content;
+              lines.push(`- (${row.type}${tagStr}) ${date}: ${content}`);
+            }
+            lines.push("");
+            lines.push(
+              "This is BM25-only (fast, shallow). MUST call recall() for hybrid search (BM25 + vector) with more results and filters."
+            );
+            recallContext = lines.join("\n");
+            logToFile(
+              `UserPromptSubmit: injected ${rows.length} memorie(s) for prompt: ${prompt2.slice(0, 80)}`
+            );
+            feedback("\u{1F4A1}", `remem-mcp: injected ${rows.length} memorie(s) matching your prompt`);
+          }
+        }
+      }
+      try {
+        const scenarios = db.prepare("SELECT summary FROM scenarios ORDER BY created_at DESC LIMIT 3").all();
+        if (scenarios.length > 0) {
+          const scenarioLines = scenarios.map((s) => `- ${s.summary}`);
+          if (recallContext) {
+            recallContext += `
+
+## Scenarios (L2 summaries)
+${scenarioLines.join("\n")}`;
+          } else {
+            recallContext = `[remem-mcp] Scenarios (L2 summaries):
+${scenarioLines.join("\n")}`;
+          }
+        }
+      } catch {
+      }
+      try {
+        const personaRow = db.prepare("SELECT content FROM persona WHERE team_id = ? AND user_id = ? ORDER BY updated_at DESC LIMIT 1").get("default", "default");
+        if (personaRow && personaRow.content) {
+          if (recallContext) {
+            recallContext += `
+
+## Persona (L3)
+${personaRow.content}`;
+          } else {
+            recallContext = `[remem-mcp] Persona (L3):
+${personaRow.content}`;
+          }
+        }
+      } catch {
+      }
+      try {
+        const skills = db.prepare("SELECT name, description FROM skills ORDER BY updated_at DESC LIMIT 3").all();
+        if (skills.length > 0) {
+          const skillLines = skills.map((s) => `- ${s.name}: ${(s.description || "").slice(0, 80)}`);
+          if (recallContext) {
+            recallContext += `
+
+## Skills
+${skillLines.join("\n")}`;
+          } else {
+            recallContext = `[remem-mcp] Skills:
+${skillLines.join("\n")}`;
+          }
+        }
+      } catch {
+      }
+      db.close();
+      if (recallContext || captured) {
+        const parts = [];
+        if (captured) {
+          parts.push(
+            `[remem-mcp] Saved your ${updateFact.type} to memory: "${updateFact.fact.slice(0, 100)}"`
+          );
+        }
+        if (recallContext) {
+          parts.push(recallContext);
+        }
+        const output2 = {
+          hookSpecificOutput: {
+            hookEventName: "UserPromptSubmit",
+            additionalContext: parts.join("\n\n")
+          }
+        };
+        process.stdout.write(JSON.stringify(output2));
+      } else {
+        const output2 = {
+          hookSpecificOutput: {
+            hookEventName: "UserPromptSubmit",
+            additionalContext: "[remem-mcp] No BM25 matches found. Call recall() for hybrid search (BM25 + vector) if you need project context."
+          }
+        };
+        process.stdout.write(JSON.stringify(output2));
+      }
+    } catch (err) {
+      process.stderr.write(`[remem-mcp hook-user-prompt] Error: ${err}
+`);
+      logToFile(`UserPromptSubmit: error - ${err}`);
+      process.stdout.write(JSON.stringify({}));
+    }
+  });
+}
 function hookStop(dbPath) {
   const chunks = [];
   process.stdin.setEncoding("utf-8");
@@ -4340,15 +4948,23 @@ function hookStop(dbPath) {
           logToFile(`Stop: capture error - ${err}`);
         });
       } else {
-        const scriptPath = process.argv[1];
+        const scriptPath2 = process.argv[1];
         const child = spawn2(
           process.execPath,
-          [scriptPath, "--wait-and-capture", dbPath, sid, tpath ?? ""],
+          [scriptPath2, "--wait-and-capture", dbPath, sid, tpath ?? ""],
           { detached: true, stdio: "ignore" }
         );
         child.unref();
         logToFile(`Stop: spawned background capture for session ${sid}`);
       }
+      const scriptPath = process.argv[1];
+      const workerChild = spawn2(
+        process.execPath,
+        [scriptPath, "worker-run", dbPath],
+        { detached: true, stdio: "ignore" }
+      );
+      workerChild.unref();
+      logToFile(`Stop: spawned background pipeline worker for session ${sid}`);
     }
     if (input.stop_hook_active) {
       process.stdout.write(JSON.stringify({}));
@@ -4420,7 +5036,7 @@ function hookPostToolUse(dbPath) {
       }
       if (isWriteEdit) {
         try {
-          const db2 = new Database7(dbPath);
+          const db2 = new Database8(dbPath);
           const sessionKey2 = hashPath(input.cwd ?? toolInput.workdir ?? process.cwd());
           const pattern = detectPattern(toolName, toolInput);
           if (pattern) {
@@ -4521,7 +5137,7 @@ function hookPostToolUse(dbPath) {
           try {
             const driftRecords = checkAllDriftInjections(sessionKey2);
             if (driftRecords.length > 0 && pattern) {
-              const driftDb = new Database7(dbPath);
+              const driftDb = new Database8(dbPath);
               for (const dr of driftRecords) {
                 if (dr.type === "pattern") {
                   const injectedPat = driftDb.prepare("SELECT id, metadata FROM captures WHERE id = ?").get(dr.content_hash);
@@ -4570,7 +5186,7 @@ function hookPostToolUse(dbPath) {
       }
       let db;
       try {
-        db = new Database7(dbPath);
+        db = new Database8(dbPath);
       } catch {
         process.stdout.write(JSON.stringify({}));
         return;
@@ -4952,7 +5568,7 @@ Error (${errorType}): ${normalizedError}`;
       db.close();
       logToFile(`PostToolUse: auto-captured ${errorType} error. id=${id}`);
       try {
-        const corrDb = new Database7(dbPath);
+        const corrDb = new Database8(dbPath);
         const recentErrors = corrDb.prepare(
           `SELECT id, json_extract(metadata, '$.error_type') as etype, json_extract(metadata, '$.title') as title
              FROM captures
@@ -5054,7 +5670,7 @@ function hookPreToolUse(dbPath) {
           const cwd2 = input.cwd ?? toolInput.workdir ?? process.cwd();
           const sessionKey2 = hashPath(cwd2);
           try {
-            const predDb = new Database7(dbPath, { readonly: true });
+            const predDb = new Database8(dbPath, { readonly: true });
             const basename2 = filePath.split("/").pop() ?? filePath;
             const fileErrors = predDb.prepare(
               `SELECT
@@ -5119,7 +5735,7 @@ function hookPreToolUse(dbPath) {
             };
             const language = langMap[ext] ?? "";
             if (language) {
-              const patDb = new Database7(dbPath, { readonly: true });
+              const patDb = new Database8(dbPath, { readonly: true });
               const patterns = patDb.prepare(
                 `SELECT
                      json_extract(metadata, '$.title') as title,
@@ -5201,7 +5817,7 @@ function hookPreToolUse(dbPath) {
       const sessionKey = hashPath(cwd);
       let db;
       try {
-        db = new Database7(dbPath, { readonly: true });
+        db = new Database8(dbPath, { readonly: true });
       } catch {
         process.stdout.write(JSON.stringify({}));
         return;
@@ -5229,7 +5845,7 @@ function hookPreToolUse(dbPath) {
       db.close();
       let resolvedFixes = [];
       try {
-        const rDb = new Database7(dbPath, { readonly: true });
+        const rDb = new Database8(dbPath, { readonly: true });
         const resolved = rDb.prepare(
           `SELECT content, metadata, created_at, session_key FROM captures
              WHERE type = 'error' ${sessionFilter}
@@ -5287,7 +5903,7 @@ function hookPreToolUse(dbPath) {
       }
       if (errors2.length === 0 && resolvedFixes.length === 0) {
         try {
-          const decDb = new Database7(dbPath, { readonly: true });
+          const decDb = new Database8(dbPath, { readonly: true });
           const lowerCmd = command.toLowerCase();
           let decQuery = "";
           const decParams = [sessionKey, Date.now() - 90 * 864e5];
@@ -5446,7 +6062,7 @@ function hookPreToolUse(dbPath) {
       lines.push("");
       lines.push("Fix these issues BEFORE running the command.");
       try {
-        const decDb = new Database7(dbPath, { readonly: true });
+        const decDb = new Database8(dbPath, { readonly: true });
         const lowerCmd = command.toLowerCase();
         let decQuery = "";
         const decParams = [sessionKey, Date.now() - 90 * 864e5];
@@ -5808,7 +6424,7 @@ function detectPattern(toolName, toolInput) {
 }
 function detectCrossProjectPattern(dbPath, currentSessionKey, errorType, command) {
   try {
-    const db = new Database7(dbPath, { readonly: true });
+    const db = new Database8(dbPath, { readonly: true });
     const cmdRoot = extractCommandRoot(command);
     const others = db.prepare(
       `SELECT session_key, content, metadata, created_at FROM captures
@@ -6024,7 +6640,12 @@ async function captureSessionTranscript(dbPath, sessionId, transcriptPath, cwd)
 Task: ${taskText}
 Outcome: ${outcomeText}`;
   const contentHash = createHash3("sha256").update(content).digest("hex");
-  const db = new Database7(dbPath);
+  const db = new Database8(dbPath);
+  try {
+    const sqliteVec5 = await import("sqlite-vec");
+    sqliteVec5.load(db);
+  } catch {
+  }
   const sessionKey = hashPath(cwd ?? process.cwd());
   const now = Date.now();
   const id = generateId2();
@@ -6039,11 +6660,15 @@ Outcome: ${outcomeText}`;
   ).all(sessionKey, sid);
   if (stale.length > 0) {
     const delStmt = db.prepare("DELETE FROM captures WHERE id = ?");
-    const delVec = db.prepare("DELETE FROM captures_vec WHERE id = ?");
+    let delVec = null;
+    try {
+      delVec = db.prepare("DELETE FROM captures_vec WHERE id = ?");
+    } catch {
+    }
     const delAtoms = db.prepare("DELETE FROM atoms WHERE capture_id = ?");
     for (const row of stale) {
       delStmt.run(row.id);
-      delVec.run(row.id);
+      delVec?.run(row.id);
       delAtoms.run(row.id);
     }
     logToFile(`Stop: removed ${stale.length} previous capture(s) for session ${sid}`);
@@ -6067,8 +6692,6 @@ Outcome: ${outcomeText}`;
     })
   );
   try {
-    const sqliteVec5 = await import("sqlite-vec");
-    sqliteVec5.load(db);
     const { LocalEmbedder: LocalEmbedder2 } = (init_local(), __toCommonJS(local_exports));
     const embedder = new LocalEmbedder2();
     const embedding = await embedder.embed(content);
@@ -6170,8 +6793,8 @@ async function hookPostCommit(dbPath) {
     const { join: join16, dirname: dirname11 } = await import("path");
     const { fileURLToPath: fileURLToPath5 } = await import("url");
     const sqliteVec5 = await import("sqlite-vec");
-    const { indexFile: indexFile2 } = await import("./engine-EIOBO7ZE.js");
-    const db = new Database7(dbPath);
+    const { indexFile: indexFile2 } = await import("./engine-LVKGZHBY.js");
+    const db = new Database8(dbPath);
     try {
       db.pragma("journal_mode = WAL");
       sqliteVec5.load(db);
@@ -6244,7 +6867,7 @@ function hookPreCompact(dbPath) {
       const input = raw.trim() ? JSON.parse(raw) : {};
       const trigger = input.trigger ?? "unknown";
       const sessionKey = hashPath(input.cwd ?? process.cwd());
-      const db = new Database7(dbPath);
+      const db = new Database8(dbPath);
       let transcriptNote = "";
       try {
         db.pragma("journal_mode = WAL");
@@ -6354,7 +6977,7 @@ function hookPostCompaction(dbPath) {
       const globalKey = process.env.REMEM_GLOBAL_SESSION_KEY ?? null;
       const { fileURLToPath: fileURLToPath5 } = await import("url");
       const schemaPath = join8(dirname4(fileURLToPath5(import.meta.url)), "storage", "schema.sql");
-      const db = new Database7(dbPath, { readonly: true });
+      const db = new Database8(dbPath, { readonly: true });
       const cutoff = Date.now() - 24 * 60 * 60 * 1e3;
       const sessionKeys = globalKey ? [sessionKey, globalKey] : [sessionKey];
       const placeholders = sessionKeys.map(() => "?").join(",");
@@ -6476,6 +7099,17 @@ var HOOKS_CONFIG = {
   // Devin supports: PreToolUse, PostToolUse, UserPromptSubmit, Stop,
   // PostCompaction, SessionStart, SessionEnd, PermissionRequest.
   // Error capture is handled via PostToolUse with exit code 2.
+  UserPromptSubmit: [
+    {
+      hooks: [
+        {
+          type: "command",
+          command: hookCommand("hook-user-prompt"),
+          timeout: 5
+        }
+      ]
+    }
+  ],
   Stop: [
     {
       hooks: [
@@ -6547,14 +7181,26 @@ function installClaudeCodeHooks() {
   if (!existsSync8(claudeDir)) {
     return false;
   }
+  const { PostCompaction: _omit, ...baseWithoutPostCompaction } = HOOKS_CONFIG;
   const claudeHooksConfig = {
-    ...HOOKS_CONFIG,
+    ...baseWithoutPostCompaction,
     PreCompact: [
       {
         hooks: [
           {
             type: "command",
-            command: hookCommand("hook-pre-compact"),
+            command: hookCommand("hook-pre-compact"),
+            timeout: 10
+          }
+        ]
+      }
+    ],
+    PostCompact: [
+      {
+        hooks: [
+          {
+            type: "command",
+            command: hookCommand("hook-post-compaction"),
             timeout: 10
           }
         ]
@@ -6617,6 +7263,15 @@ command = "${hookCommand("hook-post-compaction")}"
 timeout = 10
 # <<< remem-mcp PostCompaction <<<
 
+# >>> remem-mcp UserPromptSubmit >>>
+[[hooks.UserPromptSubmit]]
+
+[[hooks.UserPromptSubmit.hooks]]
+type = "command"
+command = "${hookCommand("hook-user-prompt")}"
+timeout = 5
+# <<< remem-mcp UserPromptSubmit <<<
+
 # >>> remem-mcp Stop >>>
 [[hooks.Stop]]
 
@@ -6656,10 +7311,12 @@ async function installHooks() {
 Hooks wired to ${installed} agent(s).`);
   console.log("\nHooks installed:");
   console.log("  SessionStart \u2192 auto-recall recent memory into agent context");
+  console.log("  UserPromptSubmit \u2192 heuristic recall: inject memory matching user prompt");
   console.log("  PreToolUse   \u2192 inject past errors before lint/build/test commands");
   console.log("  PostToolUse  \u2192 auto-capture failed commands as error memories");
-  console.log("  PreCompact     \u2192 save checkpoint before compaction (Claude Code only)");
-  console.log("  PostCompaction \u2192 re-inject memory after compaction (all agents)");
+  console.log("  PreCompact   \u2192 save checkpoint before compaction (Claude Code only)");
+  console.log("  PostCompact  \u2192 re-inject memory after compaction (Claude Code)");
+  console.log("  PostCompaction \u2192 re-inject memory after compaction (Devin CLI, Codex CLI)");
   console.log("  Stop         \u2192 auto-capture session transcript + remind to save");
   console.log("  SessionEnd   \u2192 silently capture session summary to memory DB");
   console.log("\nRestart your agent for hooks to take effect.");
@@ -6675,7 +7332,9 @@ async function uninstallHooks() {
     "PreToolUse",
     "PostToolUse",
     "PreCompact",
-    "PostCompaction"
+    "PostCompact",
+    "PostCompaction",
+    "UserPromptSubmit"
   ];
   const devinPath = join9(homedir7(), ".config", "devin", "config.json");
   if (existsSync8(devinPath)) {
@@ -6750,7 +7409,7 @@ init_esm_shims();
 import { existsSync as existsSync9, readFileSync as readFileSync7 } from "fs";
 import { dirname as dirname6, join as join10 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
-import Database8 from "better-sqlite3";
+import Database9 from "better-sqlite3";
 import * as sqliteVec3 from "sqlite-vec";
 var __dirname3 = dirname6(fileURLToPath3(import.meta.url));
 function ensureSchema2(db) {
@@ -6789,7 +7448,7 @@ function importData(dbPath, inputPath) {
     console.error("Error: No captures array in the file.");
     process.exit(1);
   }
-  const db = new Database8(dbPath);
+  const db = new Database9(dbPath);
   db.pragma("journal_mode = WAL");
   db.pragma("synchronous = NORMAL");
   sqliteVec3.load(db);
@@ -7025,16 +7684,6 @@ Skill installed to ${installed} location(s).`);
   console.log("  - Forget only on explicit user request");
 }
 
-// src/pipeline/noop.ts
-init_esm_shims();
-var NoopPipeline = class {
-  name = "noop";
-  requiresLLM = false;
-  async process(_input, _ctx) {
-    return {};
-  }
-};
-
 // src/security/audit.ts
 init_esm_shims();
 import { createHash as createHash4 } from "crypto";
@@ -7075,6 +7724,7 @@ var AuditLogger = class {
 
 // src/server.ts
 init_esm_shims();
+init_engine();
 import { createHash as createHash5 } from "crypto";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import {
@@ -7137,6 +7787,7 @@ function formatResults(results) {
 }
 
 // src/server.ts
+init_ulid();
 function defaultSessionKey() {
   if (process.env.REMEM_SESSION_KEY) return process.env.REMEM_SESSION_KEY;
   const cwd = process.cwd();
@@ -7149,6 +7800,8 @@ function detectAgentId() {
   if (process.env.DEVIN_SESSION_ID) return "devin";
   if (process.env.CLAUDE_CODE_ENTRYPOINT) return "claude";
   if (process.env.CURSOR_DEBUG) return "cursor";
+  if (process.env.CODEX_HOME) return "codex";
+  if (process.env.WINDSURF_USER_KEY) return "windsurf";
   return "unknown";
 }
 function dedupByContentPrefix(results, prefixLen = 60) {
@@ -7298,11 +7951,20 @@ var TOOLS = [
           default: false,
           description: "Set this to true to force capture even if the content was previously rejected. Use this only when the rejection reason no longer applies."
         },
+        override_reason: {
+          type: "string",
+          description: "Required when override_rejection is true. Explain why the rejection no longer applies. Logged to audit."
+        },
         auto_global: {
           type: "boolean",
           default: false,
           description: "Set to true to auto-classify: generic rules/learnings go to global, project-specific content stays in project. Only applies when session_key is not explicitly set. Requires REMEM_GLOBAL_SESSION_KEY to be configured."
         },
+        atoms: {
+          type: "array",
+          items: { type: "string" },
+          description: "Optional L1 atom facts distilled from this capture. Each atom is a short, self-contained fact useful on its own (e.g., 'vitest config missing causes npm test exit 1'). When provided, recall() returns these atoms instead of the raw content \u2014 90% fewer tokens. Write 1-3 atoms for decisions, learnings, and errors. Skip for conversations."
+        },
         format: {
           type: "string",
           enum: ["text", "json"],
@@ -7629,6 +8291,52 @@ var TOOLS = [
       required: ["knowledge_ids"]
     }
   },
+  // ─── L2 scenario consolidation ───────────────────────────────
+  {
+    name: "scenario_create",
+    description: "Consolidate multiple L1 atoms into an L2 scenario summary. Call this when you have 5+ atoms about the same topic \u2014 it creates a high-signal summary that recall injects in ~100 tokens instead of 5+ individual atoms. No LLM needed \u2014 you write the summary yourself based on the atoms you've seen.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        atom_ids: {
+          type: "array",
+          items: { type: "string" },
+          description: "The L1 atom IDs to consolidate (1-20)."
+        },
+        summary: {
+          type: "string",
+          description: "A 1-3 sentence summary that captures the key insight from these atoms. Write it as a self-contained fact useful on its own."
+        },
+        persona_tags: {
+          type: "array",
+          items: { type: "string" },
+          description: "Optional tags for categorization (e.g., ['database', 'migration'])."
+        },
+        ...TENANT_PARAMS
+      },
+      required: ["atom_ids", "summary"]
+    }
+  },
+  // ─── L3 persona update ───────────────────────────────────────
+  {
+    name: "persona_update",
+    description: "Update the L3 persona profile for this user/team. Call this when you notice a user preference or pattern (e.g., 'prefers concise output', 'works in Vietnamese', 'uses AZR project'). Persona is injected at SessionStart \u2014 every session gets it automatically in ~50 tokens. No LLM needed \u2014 you write the trait/value yourself.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        trait: {
+          type: "string",
+          description: "The trait name (e.g., 'language', 'output_style', 'project', 'timezone')."
+        },
+        value: {
+          type: "string",
+          description: "The trait value (e.g., 'Vietnamese', 'concise', 'AZR', 'Asia/Ho_Chi_Minh')."
+        },
+        ...TENANT_PARAMS
+      },
+      required: ["trait", "value"]
+    }
+  },
   // ─── Skill management tools ──────────────────────────────────
   {
     name: "skill_get",
@@ -7787,6 +8495,27 @@ var TOOLS = [
       required: ["file_path"]
     }
   },
+  {
+    name: "codegraph_detect_changes",
+    description: "Detect uncommitted git changes and map them to affected symbols with blast radius. Runs `git diff --name-only` to find changed files, finds symbols in those files, then traces callers to determine impact. Returns affected symbols + risk classification.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        repo_path: {
+          type: "string",
+          description: "The repository root path (absolute)."
+        },
+        team_id: { type: "string", description: "The team ID for isolation." },
+        max_depth: {
+          type: "integer",
+          default: 3,
+          maximum: 5,
+          description: "Max depth for caller traversal (blast radius)."
+        }
+      },
+      required: ["repo_path"]
+    }
+  },
   // ─── Wiki tools ───
   {
     name: "wiki_ingest",
@@ -8143,7 +8872,7 @@ function createServer(opts) {
           tags: r.tags ? JSON.parse(r.tags) : [],
           createdAt: r.created_at,
           trustState: r.trust_state ?? "candidate",
-          supersededBy: r.superseded_by,
+          supersededBy: r.superseded_by ?? void 0,
           teamId: r.team_id,
           userId: r.user_id,
           taskId: r.task_id,
@@ -8216,6 +8945,10 @@ function createServer(opts) {
         return handleKnowledgeList(args, opts);
       case "knowledge_delete":
         return handleKnowledgeDelete(args, opts);
+      case "scenario_create":
+        return handleScenarioConsolidate(args, opts);
+      case "persona_update":
+        return handlePersonaUpdate(args, opts);
       case "skill_get":
         return handleSkillGet(args, opts);
       case "skill_list":
@@ -8234,6 +8967,8 @@ function createServer(opts) {
         return handleCodegraphImpact(args, opts);
       case "codegraph_list":
         return handleCodegraphList(args, opts);
+      case "codegraph_detect_changes":
+        return handleCodegraphDetectChanges(args, opts);
       case "wiki_ingest":
         return handleWikiIngest(args, opts);
       case "wiki_search":
@@ -8307,11 +9042,11 @@ async function handleRecall(args, opts) {
     }
   }
   const globalKey = globalSessionKey();
-  const useGlobalFallback = globalKey && !args.session_key && globalKey !== sessionKey;
+  const useGlobalFallback = !!globalKey && !args.session_key && globalKey !== sessionKey;
   let results;
   if (useGlobalFallback) {
     const reservedGlobal = Math.min(3, limit);
-    const projectLimit = limit - reservedGlobal;
+    const projectLimit = Math.max(1, limit - reservedGlobal);
     const projectResults = await opts.storage.search(query, queryEmbedding, {
       sessionKey,
       limit: projectLimit,
@@ -8343,28 +9078,36 @@ async function handleRecall(args, opts) {
     });
   }
   results = dedupByContentPrefix(results, 60);
-  let text = formatResults(results);
-  if (format === "json") {
-    const atomMap = /* @__PURE__ */ new Map();
-    for (const r of results) {
-      try {
-        const atoms = await opts.pipelineCtx.storage.listAtoms({ captureId: r.entry.id, limit: 5 });
-        if (atoms.length > 0) {
-          atomMap.set(r.entry.id, atoms.map((a) => a.fact).join(" | "));
-        }
-      } catch {
+  const atomMap = /* @__PURE__ */ new Map();
+  for (const r of results) {
+    try {
+      const atoms = await opts.pipelineCtx.storage.listAtoms({ captureId: r.entry.id, limit: 5 });
+      if (atoms.length > 0) {
+        atomMap.set(r.entry.id, atoms.map((a) => a.fact).join(" | "));
       }
+    } catch {
+    }
+  }
+  for (const r of results) {
+    const atomContent = atomMap.get(r.entry.id);
+    if (atomContent) {
+      r.entry = { ...r.entry, content: atomContent };
     }
+  }
+  let text = formatResults(results);
+  if (format === "json") {
     const jsonResults = results.map((r) => ({
       id: r.entry.id,
-      content: atomMap.get(r.entry.id) ?? r.entry.content,
+      content: r.entry.content,
       score: r.score,
       type: r.entry.type,
       tags: r.entry.tags,
       created_at: new Date(r.entry.createdAt).toISOString(),
       trust_state: r.entry.trustState ?? "candidate"
     }));
-    const jsonText = JSON.stringify(jsonResults);
+    const jsonText = JSON.stringify(
+      vectorDegraded ? { results: jsonResults, _meta: { vector_degraded: true, channels_run: ["keyword"] } } : { results: jsonResults, _meta: { channels_run: mode === "vector" ? ["vector"] : ["keyword", "vector"] } }
+    );
     opts.audit.log({
       tool: "recall",
       argsHash: AuditLogger.hashArgs({ query, limit, offset, mode, teamId, userId, taskId }),
@@ -8402,6 +9145,24 @@ ${wikiLines.join("\n")}`;
     }
   } catch {
   }
+  try {
+    const scenarios = await opts.storage.listScenarios({
+      teamId,
+      agentId,
+      userId,
+      limit: 3
+    });
+    if (scenarios.length > 0) {
+      const scenarioLines = scenarios.map(
+        (s) => `  ${s.summary}`
+      );
+      text += `
+
+## Scenarios (L2 summaries)
+${scenarioLines.join("\n")}`;
+    }
+  } catch {
+  }
   if (vectorDegraded) {
     text = `[note: vector search unavailable, results are keyword-only]
 ${text}`;
@@ -8442,6 +9203,7 @@ async function handleCapture(args, opts) {
   const verified = args.verified ?? false;
   const supersedes = args.supersedes;
   const overrideRejection = args.override_rejection ?? false;
+  const overrideReason = args.override_reason;
   const format = args.format ?? (args.agent_id !== void 0 ? "json" : "text");
   let content;
   let messages;
@@ -8491,12 +9253,30 @@ async function handleCapture(args, opts) {
         content: [
           {
             type: "text",
-            text: `Blocked: This content was previously rejected (${rejected[0].id}). Reason: ${reason}. Set override_rejection to true to force capture.`
+            text: `Blocked: This content was previously rejected (${rejected[0].id}). Reason: ${reason}. Set override_rejection: true and override_reason: "<why>" to force capture.`
           }
         ],
         isError: true
       };
     }
+  } else if (!overrideReason) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: "Error: override_rejection is true but override_reason is missing. Provide a reason explaining why the rejection no longer applies."
+        }
+      ],
+      isError: true
+    };
+  } else {
+    opts.audit.log({
+      tool: "capture",
+      argsHash: AuditLogger.hashArgs({ type: type2, tags, sessionKey, overrideReason, teamId, userId, taskId }),
+      resultLen: 0,
+      quotaHit: false,
+      redacted: wasRedacted
+    });
   }
   const existing = await opts.storage.findByContentHash(contentHash, sessionKey, agentId);
   if (existing.length > 0) {
@@ -8618,6 +9398,31 @@ Call resolve to mark one as superseding the other.`;
       console.error(`[remem-mcp] Pipeline failed: ${err}`);
     }
   }
+  const agentAtoms = args.atoms;
+  if (agentAtoms && agentAtoms.length > 0) {
+    try {
+      try {
+        opts.pipelineCtx.storage.deleteAtomsByCaptureId(id);
+      } catch {
+      }
+      for (const fact of agentAtoms.slice(0, 5)) {
+        const atomId = generateId();
+        await opts.pipelineCtx.storage.putAtom({
+          id: atomId,
+          captureId: id,
+          fact,
+          confidence: 0.95,
+          // agent-written atoms are high confidence
+          createdAt: Date.now(),
+          teamId,
+          agentId,
+          userId
+        });
+      }
+    } catch (err) {
+      console.error(`[remem-mcp] Agent atom save failed: ${err}`);
+    }
+  }
   opts.audit.log({
     tool: "capture",
     argsHash: AuditLogger.hashArgs({ type: type2, tags, sessionKey, teamId, userId, taskId }),
@@ -8679,7 +9484,7 @@ async function handleSearch(args, opts) {
   }
   const sessionKey = args.session_key ?? defaultSessionKey();
   const globalKey = globalSessionKey();
-  const useGlobalFallback = globalKey && !args.session_key && globalKey !== sessionKey;
+  const useGlobalFallback = !!globalKey && !args.session_key && globalKey !== sessionKey;
   const searchFilters = filters ? {
     type: filters.type,
     tags: filters.tags,
@@ -8693,7 +9498,7 @@ async function handleSearch(args, opts) {
   let results;
   if (useGlobalFallback) {
     const reservedGlobal = Math.min(3, limit);
-    const projectLimit = limit - reservedGlobal;
+    const projectLimit = Math.max(1, limit - reservedGlobal);
     const projectResults = await opts.storage.search(query, queryEmbedding, {
       sessionKey,
       limit: projectLimit,
@@ -8725,27 +9530,35 @@ async function handleSearch(args, opts) {
     });
   }
   results = dedupByContentPrefix(results, 60);
-  if (format === "json") {
-    const atomMap = /* @__PURE__ */ new Map();
-    for (const r of results) {
-      try {
-        const atoms = await opts.pipelineCtx.storage.listAtoms({ captureId: r.entry.id, limit: 5 });
-        if (atoms.length > 0) {
-          atomMap.set(r.entry.id, atoms.map((a) => a.fact).join(" | "));
-        }
-      } catch {
+  const atomMap = /* @__PURE__ */ new Map();
+  for (const r of results) {
+    try {
+      const atoms = await opts.pipelineCtx.storage.listAtoms({ captureId: r.entry.id, limit: 5 });
+      if (atoms.length > 0) {
+        atomMap.set(r.entry.id, atoms.map((a) => a.fact).join(" | "));
       }
+    } catch {
     }
+  }
+  for (const r of results) {
+    const atomContent = atomMap.get(r.entry.id);
+    if (atomContent) {
+      r.entry = { ...r.entry, content: atomContent };
+    }
+  }
+  if (format === "json") {
     const jsonResults = results.map((r) => ({
       id: r.entry.id,
-      content: atomMap.get(r.entry.id) ?? r.entry.content,
+      content: r.entry.content,
       score: r.score,
       type: r.entry.type,
       tags: r.entry.tags,
       created_at: new Date(r.entry.createdAt).toISOString(),
       trust_state: r.entry.trustState ?? "candidate"
     }));
-    const jsonText = JSON.stringify(jsonResults);
+    const jsonText = JSON.stringify(
+      vectorDegraded ? { results: jsonResults, _meta: { vector_degraded: true, channels_run: ["keyword"] } } : { results: jsonResults, _meta: { channels_run: mode === "vector" ? ["vector"] : ["keyword", "vector"] } }
+    );
     opts.audit.log({
       tool: "search",
       argsHash: AuditLogger.hashArgs({ query, mode, filters }),
@@ -8921,7 +9734,7 @@ async function handleExplainRecall(args, opts) {
   const captureId = args.capture_id;
   const sessionKey = args.session_key ?? defaultSessionKey();
   const globalKey = globalSessionKey();
-  const useGlobalFallback = globalKey && !args.session_key && globalKey !== sessionKey;
+  const useGlobalFallback = !!globalKey && !args.session_key && globalKey !== sessionKey;
   const mode = args.mode ?? "hybrid";
   const limit = Math.min(args.limit ?? 10, 50);
   const { teamId, userId, taskId } = extractTenant(args);
@@ -8940,7 +9753,7 @@ async function handleExplainRecall(args, opts) {
     queryEmbedding,
     useGlobalFallback,
     sessionKey,
-    globalKey,
+    globalKey: globalKey ?? void 0,
     teamId,
     userId,
     taskId
@@ -9558,10 +10371,18 @@ async function handleSupersede(args, opts) {
       isError: true
     };
   }
-  db.prepare("UPDATE captures SET superseded_by = ?, trust_state = 'stale' WHERE id = ?").run(
-    newId,
-    oldId
-  );
+  const { updated } = await opts.storage.supersede(oldId, newId);
+  if (updated === 0) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: Old capture ${oldId} could not be superseded (it may already be rejected).`
+        }
+      ],
+      isError: true
+    };
+  }
   return {
     content: [
       {
@@ -9627,13 +10448,13 @@ async function handleCorrectionKPIs(_args, opts) {
 async function handleSessionStart(args, opts) {
   const sessionKey = args.session_key ?? defaultSessionKey();
   const globalKey = globalSessionKey();
-  const useGlobalFallback = globalKey && !args.session_key && globalKey !== sessionKey;
+  const useGlobalFallback = !!globalKey && !args.session_key && globalKey !== sessionKey;
   const contextQuery = args.context_query;
   const db = getDb(opts);
   const sessionKeys = useGlobalFallback ? [sessionKey, globalKey] : [sessionKey];
   const placeholders = sessionKeys.map(() => "?").join(",");
   const recent = db.prepare(
-    `SELECT id, type, content, tags, created_at FROM captures WHERE deleted_at IS NULL AND session_key IN (${placeholders}) ORDER BY created_at DESC LIMIT 5`
+    `SELECT id, session_key, type, content, tags, created_at FROM captures WHERE deleted_at IS NULL AND session_key IN (${placeholders}) ORDER BY created_at DESC LIMIT 5`
   ).all(...sessionKeys);
   const kpis = opts.storage.getCorrectionKPIs();
   let contextResults = [];
@@ -10184,6 +11005,99 @@ async function handleKnowledgeDelete(args, opts) {
   });
   return { content: [{ type: "text", text: `Deleted ${count} knowledge asset(s).` }] };
 }
+async function handleScenarioConsolidate(args, opts) {
+  const atomIds = args.atom_ids;
+  const summary = args.summary;
+  const personaTags = args.persona_tags;
+  const { teamId, userId, taskId } = extractTenant(args);
+  const agentId = args.agent_id ?? detectAgentId();
+  if (!atomIds || atomIds.length === 0) {
+    return { content: [{ type: "text", text: "Error: atom_ids is required." }], isError: true };
+  }
+  if (!summary || summary.trim().length < 10) {
+    return { content: [{ type: "text", text: "Error: summary must be at least 10 characters." }], isError: true };
+  }
+  if (atomIds.length > 20) {
+    return { content: [{ type: "text", text: "Error: Maximum 20 atom_ids per consolidation." }], isError: true };
+  }
+  const id = generateId();
+  const scenario = {
+    id,
+    atomIds,
+    summary: summary.trim(),
+    personaTags,
+    createdAt: Date.now(),
+    teamId,
+    agentId,
+    userId
+  };
+  try {
+    await opts.storage.putScenario(scenario);
+  } catch (err) {
+    return { content: [{ type: "text", text: `Error: ${err}` }], isError: true };
+  }
+  opts.audit.log({
+    tool: "consolidate",
+    argsHash: AuditLogger.hashArgs({ atomIds, summary }),
+    resultLen: id.length,
+    quotaHit: false,
+    redacted: false
+  });
+  return {
+    content: [
+      {
+        type: "text",
+        text: `Consolidated ${atomIds.length} atoms into scenario ${id}. Recall will inject this summary automatically.`
+      }
+    ]
+  };
+}
+async function handlePersonaUpdate(args, opts) {
+  const trait = args.trait;
+  const value = args.value;
+  const { teamId, userId } = extractTenant(args);
+  const agentId = args.agent_id ?? detectAgentId();
+  if (!trait || !value) {
+    return { content: [{ type: "text", text: "Error: trait and value are required." }], isError: true };
+  }
+  const tid = teamId ?? "default";
+  const uid = userId ?? "default";
+  let existing = await opts.storage.readPersona(tid, agentId, uid);
+  let content;
+  if (existing) {
+    const lines = existing.content.split("\n").filter((l) => l.trim());
+    const traitPattern = new RegExp(`^${trait.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}:`, "i");
+    const idx = lines.findIndex((l) => traitPattern.test(l));
+    if (idx >= 0) {
+      lines[idx] = `${trait}: ${value}`;
+    } else {
+      lines.push(`${trait}: ${value}`);
+    }
+    content = lines.join("\n");
+  } else {
+    content = `${trait}: ${value}`;
+  }
+  try {
+    await opts.storage.writePersona(tid, agentId, uid, content);
+  } catch (err) {
+    return { content: [{ type: "text", text: `Error: ${err}` }], isError: true };
+  }
+  opts.audit.log({
+    tool: "persona_update",
+    argsHash: AuditLogger.hashArgs({ trait, value }),
+    resultLen: content.length,
+    quotaHit: false,
+    redacted: false
+  });
+  return {
+    content: [
+      {
+        type: "text",
+        text: `Persona updated: ${trait} = ${value}. SessionStart will inject this automatically.`
+      }
+    ]
+  };
+}
 async function handleSkillGet(args, opts) {
   const skillId = args.skill_id;
   const entry = await opts.storage.getSkill(skillId);
@@ -10420,6 +11334,95 @@ ${lines.join("\n")}`
     ]
   };
 }
+function handleCodegraphDetectChanges(args, opts) {
+  const repoPath = args.repo_path;
+  const teamId = args.team_id ?? void 0;
+  const maxDepth = args.max_depth ?? 3;
+  if (!repoPath) {
+    return { content: [{ type: "text", text: "Error: repo_path is required." }], isError: true };
+  }
+  const db = getDb(opts);
+  let changedFiles;
+  try {
+    const { execSync: execSync3 } = __require("child_process");
+    const output2 = execSync3("git diff --name-only HEAD", {
+      cwd: repoPath,
+      encoding: "utf-8",
+      timeout: 5e3
+    }).trim();
+    changedFiles = output2 ? output2.split("\n") : [];
+    const staged = execSync3("git diff --cached --name-only", {
+      cwd: repoPath,
+      encoding: "utf-8",
+      timeout: 5e3
+    }).trim();
+    if (staged) {
+      const stagedFiles = staged.split("\n");
+      changedFiles = [.../* @__PURE__ */ new Set([...changedFiles, ...stagedFiles])];
+    }
+  } catch {
+    return {
+      content: [{ type: "text", text: "Error: Failed to run git diff. Is this a git repository?" }],
+      isError: true
+    };
+  }
+  if (changedFiles.length === 0) {
+    return { content: [{ type: "text", text: "No uncommitted changes detected." }] };
+  }
+  const placeholders = changedFiles.map(() => "?").join(",");
+  const changedSymbols = db.prepare(
+    `SELECT id, name, kind, file_path, line_start, line_end FROM symbols WHERE file_path IN (${placeholders})`
+  ).all(...changedFiles);
+  if (changedSymbols.length === 0) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Changed files: ${changedFiles.length}, but no indexed symbols found. Run codegraph_index first.`
+        }
+      ]
+    };
+  }
+  const { impactAnalysis: impactAnalysis2 } = (init_engine(), __toCommonJS(engine_exports));
+  const results = [];
+  for (const sym of changedSymbols) {
+    try {
+      const impact = impactAnalysis2(db, sym.id, { maxDepth });
+      const callerCount = impact.affected.length;
+      const risk = callerCount >= 10 ? "high" : callerCount >= 3 ? "medium" : "low";
+      results.push({
+        symbol: {
+          name: sym.name,
+          kind: sym.kind,
+          file: sym.file_path,
+          line: sym.line_start
+        },
+        callers: impact.affected.slice(0, 5).map((a) => ({
+          name: a.symbol.name,
+          depth: a.depth,
+          path: a.path.join(" \u2192 ")
+        })),
+        risk
+      });
+    } catch {
+    }
+  }
+  const lines = [`Changed files: ${changedFiles.length}`, `Affected symbols: ${changedSymbols.length}`, ""];
+  for (const r of results) {
+    lines.push(`[${r.risk.toUpperCase()}] ${r.symbol.kind} ${r.symbol.name} (${r.symbol.file}:${r.symbol.line})`);
+    if (r.callers.length > 0) {
+      lines.push(`  Callers (${r.callers.length} shown):`);
+      for (const c of r.callers) {
+        lines.push(`    d${c.depth}: ${c.path}`);
+      }
+    } else {
+      lines.push(`  No callers found (leaf node).`);
+    }
+  }
+  return {
+    content: [{ type: "text", text: lines.join("\n") }]
+  };
+}
 async function handleWikiIngest(args, opts) {
   const path = args.path;
   const repoPath = args.repo_path ?? path;
@@ -10531,9 +11534,9 @@ ${lines.join("\n")}` }
 
 // src/stats.ts
 init_esm_shims();
-import Database9 from "better-sqlite3";
+import Database10 from "better-sqlite3";
 function stats(dbPath) {
-  const db = new Database9(dbPath, { readonly: true });
+  const db = new Database10(dbPath, { readonly: true });
   const total = db.prepare("SELECT COUNT(*) as count FROM captures").get();
   if (total.count === 0) {
     console.log("No captures found. The database is empty.");
@@ -10662,7 +11665,7 @@ init_esm_shims();
 import { existsSync as existsSync13, readFileSync as readFileSync10 } from "fs";
 import { homedir as homedir10 } from "os";
 import { join as join13 } from "path";
-import Database10 from "better-sqlite3";
+import Database11 from "better-sqlite3";
 import { encode } from "gpt-tokenizer";
 function countTokens(text) {
   if (!text) return 0;
@@ -10670,7 +11673,7 @@ function countTokens(text) {
 }
 function tokenStats(dbPath) {
   const logPath = process.env.REMEM_HOOK_LOG_PATH ?? join13(homedir10(), ".local", "share", "remem-mcp", "session.log");
-  const db = new Database10(dbPath, { readonly: true });
+  const db = new Database11(dbPath, { readonly: true });
   const totalCaptures = db.prepare("SELECT COUNT(*) as count FROM captures").get();
   const captures = db.prepare("SELECT id, type, content, tags, created_at FROM captures ORDER BY created_at ASC").all();
   const sessions = db.prepare("SELECT COUNT(DISTINCT session_key) as count FROM captures").get();
@@ -10820,13 +11823,14 @@ function printReactExample(fmt, _countTok) {
 
 // src/viewer.ts
 init_esm_shims();
+init_engine();
 import { existsSync as existsSync14, readFileSync as readFileSync11 } from "fs";
 import { createServer as createHttpServer } from "http";
 import { homedir as homedir11 } from "os";
 import { join as join14 } from "path";
-import Database11 from "better-sqlite3";
+import Database12 from "better-sqlite3";
 function startViewer(dbPath, port) {
-  const db = new Database11(dbPath);
+  const db = new Database12(dbPath);
   const server = createHttpServer((req, res) => {
     const url = new URL(req.url ?? "/", `http://localhost:${port}`);
     if (url.pathname === "/" || url.pathname === "/index.html") {
@@ -12547,7 +13551,7 @@ function defaultDbPath3() {
   return process.env.REMEM_DB_PATH ?? join15(homedir12(), ".local", "share", "remem-mcp", "memory.db");
 }
 function openDbWithSchema(dbPath) {
-  const db = new Database12(dbPath);
+  const db = new Database13(dbPath);
   db.pragma("journal_mode = WAL");
   db.pragma("foreign_keys = OFF");
   sqliteVec4.load(db);
@@ -12572,9 +13576,14 @@ function openDbWithSchema(dbPath) {
 function parseFlags(argv) {
   const flags = {};
   for (let i = 0; i < argv.length; i++) {
-    if (argv[i]?.startsWith("--") && argv[i + 1]) {
-      flags[argv[i].slice(2)] = argv[i + 1];
-      i++;
+    if (argv[i]?.startsWith("--")) {
+      const key = argv[i].slice(2);
+      if (argv[i + 1] && !argv[i + 1].startsWith("--")) {
+        flags[key] = argv[i + 1];
+        i++;
+      } else {
+        flags[key] = "true";
+      }
     }
   }
   return flags;
@@ -12868,6 +13877,31 @@ async function main() {
     await installSkill();
     return;
   }
+  if (arg === "init") {
+    console.log(`remem-mcp init
+
+This command tells your agent to activate long-term memory for this session.
+
+\u2192 In your agent chat, type:
+
+  invoke skill remem-mcp
+
+The skill will teach the agent to:
+  1. Call recall() with your current task as query
+  2. Index code with codegraph_search (first use auto-indexes src/)
+  3. Capture decisions/learnings after completing work
+  4. Use search instead of grep for symbol lookup
+
+Hooks are already active (installed during setup):
+  - SessionStart: recent memory auto-injected
+  - UserPromptSubmit: memory matching your prompt auto-injected
+  - PostToolUse: failed commands auto-captured
+  - Stop: session transcript auto-captured
+
+You only need to invoke the skill once per session.
+After that, the agent follows the rules automatically.`);
+    return;
+  }
   if (arg === "install-hooks") {
     await installHooks();
     return;
@@ -12971,7 +14005,7 @@ async function main() {
   }
   if (arg === "recent" || arg === "list") {
     const limit = parseInt(process.argv[3] ?? "20", 10);
-    const db = new Database12(defaultDbPath3(), { readonly: true });
+    const db = new Database13(defaultDbPath3(), { readonly: true });
     const rows = db.prepare(
       `SELECT id, type, content, tags, created_at FROM captures WHERE deleted_at IS NULL ORDER BY created_at DESC LIMIT ?`
     ).all(limit);
@@ -12993,7 +14027,7 @@ ${rows.length} capture(s).`);
     return;
   }
   if (arg === "sessions") {
-    const db = new Database12(defaultDbPath3(), { readonly: true });
+    const db = new Database13(defaultDbPath3(), { readonly: true });
     const rows = db.prepare(
       `SELECT session_key, COUNT(*) as cnt, MIN(created_at) as oldest, MAX(created_at) as newest
          FROM captures WHERE deleted_at IS NULL
@@ -13021,7 +14055,7 @@ ${rows.length} session(s). Current: ${cwdHash}`);
     return;
   }
   if (arg === "tags") {
-    const db = new Database12(defaultDbPath3(), { readonly: true });
+    const db = new Database13(defaultDbPath3(), { readonly: true });
     const rows = db.prepare(
       "SELECT tags FROM captures WHERE deleted_at IS NULL AND tags IS NOT NULL AND tags != '[]'"
     ).all();
@@ -13283,6 +14317,10 @@ ${sorted.length} unique tag(s).`);
     hookRecall(defaultDbPath3());
     return;
   }
+  if (arg === "hook-user-prompt") {
+    hookUserPromptSubmit(defaultDbPath3());
+    return;
+  }
   if (arg === "hook-stop") {
     hookStop(defaultDbPath3());
     return;
@@ -13526,6 +14564,16 @@ ${sorted.length} unique tag(s).`);
     await extractCommand(defaultDbPath3(), flags);
     return;
   }
+  if (arg === "consolidate") {
+    const flags = parseFlags(process.argv.slice(3));
+    await consolidateCommand(defaultDbPath3(), flags);
+    return;
+  }
+  if (arg === "worker-run") {
+    const flags = parseFlags(process.argv.slice(3));
+    await workerCommand(defaultDbPath3(), flags);
+    return;
+  }
   if (arg === "knowledge") {
     const flags = parseFlags(process.argv.slice(3));
     await knowledgeCommand(defaultDbPath3(), flags);
@@ -13581,6 +14629,7 @@ ${"\u2500".repeat(60)}
 Setup & maintenance:
   remem-mcp                Start the MCP server (stdio)
   remem-mcp setup          Install MCP + hooks + skill (one command)
+  remem-mcp init           Show how to activate memory in your agent session
   remem-mcp install-skill  Install the agent skill for Devin CLI
   remem-mcp install-hooks  Install lifecycle hooks (SessionStart, Stop, SessionEnd)
   remem-mcp uninstall-hooks  Remove lifecycle hooks
@@ -13647,11 +14696,13 @@ Data:
   remem-mcp sync-export    Export memory to .remem-mcp/ in project root
   remem-mcp sync-import    Import memory from .remem-mcp/ (auto on startup)
 
-L1-L3 pipeline (require REMEM_LLM_API_KEY for extract):
-  remem-mcp extract        Run L1 atom extraction on existing captures
-  remem-mcp atoms          List or search L1 atoms
+L1-L3 pipeline:
+  remem-mcp extract        Run L1 atom extraction (rule-based, no LLM needed)
+  remem-mcp extract --llm  Run L1 atom extraction with LLM (needs REMEM_LLM_API_KEY)
+  remem-mcp atoms          List or search L1 atoms (--query <text> for search)
+  remem-mcp consolidate    Create L2 scenario from atoms (--atom-ids, --summary, --auto)
   remem-mcp scenarios      List L2 scenarios
-  remem-mcp persona        Read or write L3 persona
+  remem-mcp persona        Read or write L3 persona (--set "trait: value")
 
 Knowledge & skills:
   remem-mcp knowledge      List knowledge assets for a team
@@ -13707,10 +14758,8 @@ To install the skill (Devin CLI only):
     });
     pipeline = new AtomPipeline();
     pipeline._llmClient = llmClient;
-  } else if (config.pipeline === "noop") {
-    pipeline = new RuleBasedAtomPipeline();
   } else {
-    pipeline = new NoopPipeline();
+    pipeline = new RuleBasedAtomPipeline();
   }
   const audit = new AuditLogger(config.auditLogPath, config.security.auditLog);
   const pipelineCtx = {