local-agentic-ai-mem 0.1.1 → 0.2.0

package/README.md

@@ -45,6 +45,22 @@ existed locally. A memory restated later, or explicitly replaced, is marked
 superseded rather than deleted — a file changing does not mean the decision
 behind it was wrong.
 
+## What it injects — often nothing
+
+Most prompts have no relevant past work, and the honest answer is to say
+nothing. Recall applies an absolute similarity floor (`0.65`; override with
+`AGENTIC_MEMORY_THRESHOLD`) rather than always returning its best few
+candidates. On a real corpus, genuinely related queries score 0.75–0.81, an
+off-topic question 0.48, and the band that reads as noise sits at 0.59–0.60.
+
+An exact match on a path, SHA, symbol or error code is injected regardless of
+that score — that is the case embeddings are worst at, and the reason there is
+a lexical arm at all. Matching a common word is not, or the floor never fires.
+
+Memories written by the session currently asking are excluded. They are the
+model's own output on a round trip, they score a near-perfect match against the
+prompt that produced them, and they outrank everything real.
+
 ## Where it lives
 
 By default `~/.agentic-memory/memory.db`, a single SQLite file.

package/dist/commands/install.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveRuntimeRoot = resolveRuntimeRoot;
 exports.installHooks = installHooks;
 exports.registerSettings = registerSettings;
+exports.registerMcp = registerMcp;
 exports.install = install;
 /**
  * Install: write hooks, register the MCP server, create the database.
@@ -103,12 +104,49 @@ function registerSettings(home = (0, os_1.homedir)()) {
         if (!already)
             groups.push({ hooks: [{ type: "command", command }] });
     }
-    settings.mcpServers ??= {};
-    settings.mcpServers["agentic-memory"] = {
-        command: "npx",
-        args: ["-y", PKG, "mcp"],
-    };
     (0, fs_1.writeFileSync)(path, JSON.stringify(settings, null, 2) + "\n");
+    registerMcp(home);
+}
+/**
+ * Register the MCP server where Claude Code actually reads it: ~/.claude.json.
+ *
+ * It was written into settings.json next to the hooks, which looks right and
+ * is silently inert — `claude mcp list` never showed the server, so the two
+ * escape-hatch tools did not exist while the hooks worked perfectly. Nothing
+ * reports this: there is no error for a server nobody loads.
+ *
+ * The command points at the installed runtime rather than `npx -y <pkg>`, for
+ * the same reason the hooks do — see resolveRuntimeRoot. npx would also pay a
+ * registry round trip on every session start.
+ */
+function registerMcp(home = (0, os_1.homedir)()) {
+    const path = (0, path_1.join)(home, ".claude.json");
+    let config = {};
+    if ((0, fs_1.existsSync)(path)) {
+        try {
+            config = JSON.parse((0, fs_1.readFileSync)(path, "utf8"));
+        }
+        catch {
+            // This file is Claude Code's own state, not ours. If it cannot be parsed,
+            // replacing it with our two keys would delete everything it holds.
+            console.log("  MCP not registered  ~/.claude.json is unreadable; run: claude mcp add …");
+            return;
+        }
+    }
+    if (!config || typeof config !== "object" || Array.isArray(config))
+        return;
+    config.mcpServers ??= {};
+    config.mcpServers["agentic-memory"] = {
+        type: "stdio",
+        command: process.execPath,
+        args: [(0, path_1.join)(resolveRuntimeRoot(home), "dist", "index.js"), "mcp"],
+        env: {},
+    };
+    // Written via a temp file: a partial write here would leave Claude Code
+    // unable to parse its own configuration.
+    const tmp = path + ".agentic-memory.tmp";
+    (0, fs_1.writeFileSync)(tmp, JSON.stringify(config, null, 2) + "\n");
+    (0, fs_1.renameSync)(tmp, path);
 }
 function install(opts = {}) {
     console.log("\n  agentic-memory — local-first memory for Claude Code\n");
@@ -141,7 +179,7 @@ function install(opts = {}) {
     const hooks = installHooks();
     registerSettings();
     console.log(`  Hooks installed   ${hooks.length}`);
-    console.log(`  MCP registered    agentic-memory`);
+    console.log(`  MCP registered    agentic-memory (~/.claude.json)`);
     console.log(`  Database          ${require("../db").resolveDbPath(process.cwd())}`);
     console.log("\n  Nothing leaves this machine. Restart Claude Code to pick it up.\n");
 }

package/dist/commands/uninstall-legacy.js

@@ -82,7 +82,13 @@ function removeLegacyInstall(home = (0, os_1.homedir)(), apply = true) {
         if (apply)
             (0, fs_1.rmSync)(oldRoot, { recursive: true, force: true });
     }
-    report.settingsCleaned = cleanSettings((0, path_1.join)(claudeDir, "settings.json"), apply);
+    report.settingsCleaned =
+        cleanSettings((0, path_1.join)(claudeDir, "settings.json"), apply) +
+            // The hosted MCP entry lives here, not in settings.json. Deleting the shim
+            // file above without this left a server pointing at a path that no longer
+            // exists — so every session opened with a failed-connection warning, and
+            // the API key it carried stayed on disk.
+            cleanSettings((0, path_1.join)(home, ".claude.json"), apply);
     return report;
 }
 /**
@@ -124,20 +130,34 @@ function cleanSettings(path, apply = true) {
         if (Object.keys(parsed.hooks).length === 0)
             delete parsed.hooks;
     }
-    if (parsed.mcpServers && typeof parsed.mcpServers === "object") {
-        for (const key of Object.keys(parsed.mcpServers)) {
-            const entry = parsed.mcpServers[key];
+    const sweep = (holder, dropEmpty) => {
+        if (!holder?.mcpServers || typeof holder.mcpServers !== "object")
+            return;
+        for (const key of Object.keys(holder.mcpServers)) {
+            const entry = holder.mcpServers[key];
             const args = Array.isArray(entry?.args) ? entry.args : [];
             if (/memoryos|claude-memory/i.test(key) || args.some(isLegacy)) {
-                delete parsed.mcpServers[key];
+                delete holder.mcpServers[key];
                 removed++;
             }
         }
-        if (Object.keys(parsed.mcpServers).length === 0)
-            delete parsed.mcpServers;
+        if (dropEmpty && Object.keys(holder.mcpServers).length === 0)
+            delete holder.mcpServers;
+    };
+    sweep(parsed, true);
+    // ~/.claude.json also holds a per-project map, and a server registered there
+    // survives a top-level clean while still failing to connect on every start.
+    if (parsed.projects && typeof parsed.projects === "object") {
+        for (const project of Object.values(parsed.projects))
+            sweep(project, false);
+    }
+    if (apply && removed > 0) {
+        // Atomic: ~/.claude.json is Claude Code's own state, and a torn write
+        // leaves it unable to parse its configuration at all.
+        const tmp = path + ".agentic-memory.tmp";
+        (0, fs_1.writeFileSync)(tmp, JSON.stringify(parsed, null, 2) + "\n");
+        (0, fs_1.renameSync)(tmp, path);
     }
-    if (apply && removed > 0)
-        (0, fs_1.writeFileSync)(path, JSON.stringify(parsed, null, 2) + "\n");
     return removed;
 }
 /** Anything left behind that mentions the old install, for reporting. */

package/dist/db.js

@@ -247,6 +247,13 @@ function liveMemories(opts = {}) {
         where.push("m.project_id = ?");
         params.push(opts.projectId);
     }
+    // A memory written by the session now asking is not past work. It is the
+    // model's own output on a round trip, and it outranks everything real
+    // because it is a near-verbatim match for the prompt that produced it.
+    if (opts.excludeSessionId) {
+        where.push("(m.session_id IS NULL OR m.session_id <> ?)");
+        params.push(opts.excludeSessionId);
+    }
     if (opts.tier !== undefined) {
         where.push("m.tier <= ?");
         params.push(opts.tier);
@@ -331,7 +338,7 @@ function recordInjection(r) {
 }
 function openInjections(sessionId) {
     return db()
-        .prepare("SELECT id, kind, files, tokens, pitfall_files FROM injections WHERE session_id = ? AND resolved_at IS NULL")
+        .prepare("SELECT id, kind, at, files, tokens, pitfall_files FROM injections WHERE session_id = ? AND resolved_at IS NULL")
         .all(sessionId);
 }
 function resolveInjection(id, o) {

package/dist/lib/compliance.js

@@ -25,6 +25,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.distinctiveTokens = distinctiveTokens;
+exports.transcriptAfter = transcriptAfter;
 exports.readTranscript = readTranscript;
 exports.scoreInjection = scoreInjection;
 exports.formatReport = formatReport;
@@ -68,16 +69,58 @@ function distinctiveTokens(injected, prompt, max = 25) {
 function tokenize(s) {
     return (s || "").toLowerCase().replace(/[^a-z0-9._/-]+/g, " ").split(/\s+/).filter(Boolean);
 }
+/**
+ * Transcript rows carry an ISO `timestamp`. Everything that needs to ask "what
+ * happened after moment X" goes through this, because the answer is wrong in
+ * two different places without it: an injection scored against the WHOLE
+ * transcript counts words the model said before it was ever shown the memory,
+ * and extraction run over the whole transcript re-mines earlier turns and
+ * writes the same memory again on every subsequent Stop.
+ *
+ * Rows with no timestamp are kept — they are session metadata that the parsers
+ * ignore anyway, and dropping them would be a silent change to what is parsed.
+ */
+function transcriptAfter(jsonl, iso) {
+    if (!iso)
+        return jsonl || "";
+    const cutoff = new Date(iso).getTime();
+    if (!Number.isFinite(cutoff))
+        return jsonl || "";
+    const kept = [];
+    for (const line of (jsonl || "").split("\n")) {
+        const t = line.trim();
+        if (!t.startsWith("{"))
+            continue;
+        let row;
+        try {
+            row = JSON.parse(t);
+        }
+        catch {
+            continue;
+        }
+        const ts = typeof row?.timestamp === "string" ? new Date(row.timestamp).getTime() : NaN;
+        if (Number.isFinite(ts) && ts <= cutoff)
+            continue;
+        kept.push(line);
+    }
+    return kept.join("\n");
+}
 /**
  * Pull the three things compliance needs out of a Claude Code transcript.
  * Tolerates partial and malformed lines — a transcript being unparseable
  * should cost a measurement, not a session.
+ *
+ * `after` scopes it to what happened once the memory was on screen. Without
+ * it the echo signal is unfalsifiable: memories are mined from the model's own
+ * output, so a memory written in this session and injected back into it scores
+ * a perfect echo for saying nothing new. That is not a hypothetical — it was
+ * measured at cosine 1.000 against the prompt that produced it.
  */
-function readTranscript(jsonl) {
+function readTranscript(jsonl, opts = {}) {
     const read = new Set();
     const edited = new Set();
     const said = [];
-    for (const line of (jsonl || "").split("\n")) {
+    for (const line of (transcriptAfter(jsonl, opts.after) || "").split("\n")) {
         const t = line.trim();
         if (!t.startsWith("{"))
             continue;

package/dist/lib/files.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.significantFiles = significantFiles;
+/**
+ * Which touched files are worth remembering.
+ *
+ * A turn's file list is whatever the tools touched, and on a session that took
+ * screenshots or wrote a probe script that is mostly disposable paths under
+ * /tmp. They are not evidence of anything next week: the directory is gone.
+ *
+ * Keeping them is not free. The list is shown with the memory, so it spends
+ * the injection's few lines on noise, and `files_named` is the denominator of
+ * the avoided-re-read measurement — one session recorded 46 files of which 30
+ * were screenshot PNGs, which makes that number describe the screenshots.
+ */
+const DISPOSABLE_DIR = /(^|\/)(tmp|scratchpad|\.cache|node_modules|dist|\.next|coverage)(\/|$)/;
+const DISPOSABLE_EXT = /\.(png|jpe?g|gif|webp|svg|ico|pdf|zip|gz|tgz|mp4|mov|lock|log|bin|woff2?|ttf)$/i;
+function significantFiles(files, limit = 12) {
+    const out = [];
+    for (const f of files || []) {
+        if (typeof f !== "string" || !f)
+            continue;
+        if (DISPOSABLE_DIR.test(f) || DISPOSABLE_EXT.test(f))
+            continue;
+        if (out.includes(f))
+            continue;
+        out.push(f);
+        if (out.length >= limit)
+            break;
+    }
+    return out;
+}

package/dist/lib/recall.js

@@ -72,34 +72,62 @@ function safeArray(json) {
         return [];
     }
 }
-function rankArm(rows, key, q) {
+function rankArm(rows, key, q, simById) {
     const scored = [];
     for (const r of rows) {
         const v = (0, db_1.decodeVec)(r[key] ?? null);
         if (!v)
             continue;
-        scored.push({ id: r.id, sim: (0, db_1.cosine)(q, v) });
+        const sim = (0, db_1.cosine)(q, v);
+        if (simById)
+            simById.set(r.id, Math.max(simById.get(r.id) ?? -1, sim));
+        scored.push({ id: r.id, sim });
     }
     scored.sort((a, b) => b.sim - a.sim);
     return scored.slice(0, ARM_DEPTH).map((s) => s.id);
 }
+/**
+ * Which memories matched a *distinctive* term in the query.
+ *
+ * The lexical arm ORs every term, which is right for a fusion arm — broad
+ * recall, rank sorted out by RRF — and wrong as a reason to skip the relevance
+ * floor. "what is the capital city of Portugal" matches almost every memory on
+ * the word "the", so an unqualified lexical bypass let the whole corpus
+ * through and the floor never fired at all.
+ *
+ * Only identifier-shaped or unusually long terms qualify: a path, a SHA, an
+ * error code, a symbol name. Those are exactly the cases embeddings are worst
+ * at, and no ordinary English word reaches them.
+ */
+function exactMatchIds(queryText, byId) {
+    const distinctive = (queryText || "")
+        .toLowerCase()
+        .split(/[^a-z0-9_./-]+/)
+        .filter((t) => t.length > 2 && (/[._/-]/.test(t) || /\d/.test(t) || t.length >= 12));
+    if (distinctive.length === 0)
+        return new Set();
+    return new Set((0, db_1.lexicalSearch)(distinctive.join(" "), ARM_DEPTH).filter((id) => byId.has(id)));
+}
 function recall(opts) {
     const limit = opts.limit ?? 5;
     const q = opts.queryVec instanceof Float32Array ? opts.queryVec : Float32Array.from(opts.queryVec);
     // One scan serves every arm — the whole live set for this user is small.
-    const rows = (0, db_1.liveMemories)({ tier: opts.tier ?? 2 });
+    const rows = (0, db_1.liveMemories)({ tier: opts.tier ?? 2, excludeSessionId: opts.excludeSessionId });
     if (rows.length === 0)
         return [];
     const byId = new Map(rows.map((r) => [r.id, r]));
+    const simById = new Map();
+    const broadLexical = (0, db_1.lexicalSearch)(opts.queryText, ARM_DEPTH).filter((id) => byId.has(id));
+    const exactIds = exactMatchIds(opts.queryText, byId);
     const arms = [
-        rankArm(rows, "vec", q),
-        rankArm(rows, "prompt_vec", q),
-        (0, db_1.lexicalSearch)(opts.queryText, ARM_DEPTH).filter((id) => byId.has(id)),
+        rankArm(rows, "vec", q, simById),
+        rankArm(rows, "prompt_vec", q, simById),
+        broadLexical,
     ];
     if (opts.projectId !== undefined) {
         const scoped = rows.filter((r) => r.project_id === opts.projectId);
         if (scoped.length)
-            arms.push(rankArm(scoped, "vec", q));
+            arms.push(rankArm(scoped, "vec", q, simById));
     }
     const fused = new Map();
     for (const arm of arms) {
@@ -107,12 +135,17 @@ function recall(opts) {
             fused.set(id, (fused.get(id) ?? 0) + 1 / (RRF_K + rank + 1));
         });
     }
+    const minSim = opts.minSim ?? 0;
     const scored = [];
     for (const [id, rrf] of fused) {
         const row = byId.get(id);
         const text = bodyOf(row);
         if (!text)
             continue;
+        const sim = simById.get(id) ?? 0;
+        const lexical = exactIds.has(id);
+        if (minSim > 0 && sim < minSim && !lexical)
+            continue;
         const proven = Math.min(PROVEN_CAP, 1 + PROVEN_WEIGHT * Math.log1p(row.recall_count || 0));
         const sameProject = opts.projectId !== undefined && row.project_id === opts.projectId;
         scored.push({
@@ -126,6 +159,8 @@ function recall(opts) {
             gitCommit: row.git_commit,
             anchorSha: row.anchor_sha,
             confidence: row.confidence,
+            sim,
+            lexical,
             score: rrf *
                 recencyFactor(row) *
                 (sameProject ? SAME_PROJECT_BOOST : 1) *

package/dist/lib/redact.js

@@ -15,6 +15,24 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.redact = redact;
 exports.redactAll = redactAll;
+/** Real card numbers carry a check digit; almost no timestamp or id does. */
+function luhn(digits) {
+    let sum = 0;
+    let alt = false;
+    for (let i = digits.length - 1; i >= 0; i--) {
+        let d = digits.charCodeAt(i) - 48;
+        if (d < 0 || d > 9)
+            return false;
+        if (alt) {
+            d *= 2;
+            if (d > 9)
+                d -= 9;
+        }
+        sum += d;
+        alt = !alt;
+    }
+    return sum % 10 === 0;
+}
 const PATTERNS = [
     // Prefixed opaque tokens (sk-, ghp_, xoxb-, api_key-...)
     [/\b(sk|pk|rk|api|token|key|bearer|ghp|gho|ghu|ghs|ghr|xox[abprs])[-_][A-Za-z0-9_-]{16,}\b/gi, "[REDACTED_TOKEN]"],
@@ -43,8 +61,31 @@ const PATTERNS = [
     [/\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/g, "[REDACTED_EMAIL]"],
     // Public IPv4 only — private ranges are dev infra and useful context.
     [/\b(?!10\.|192\.168\.|127\.|0\.|172\.(?:1[6-9]|2\d|3[01])\.)(?:\d{1,3}\.){3}\d{1,3}\b/g, "[REDACTED_IP]"],
-    [/\b(?:\d[ -]?){13,19}\b/g, (m) => (/\d{13,19}/.test(m.replace(/[ -]/g, "")) ? "[REDACTED_CC]" : m)],
-    [/\b[a-f0-9]{32,}\b/gi, "[REDACTED_HEX]"],
+    // Card numbers must pass Luhn AND stand alone as a token. Neither test on
+    // its own is enough: `~/.claude.json.bak-20260830-112153` is fourteen digits
+    // with a separator, which the old pattern replaced with [REDACTED_CC] —
+    // destroying the one thing the memory existed to record. A memory that
+    // survives redaction as a lie is worse than one not kept, because it still
+    // costs an injection slot and now misdirects.
+    [
+        /(?<![A-Za-z0-9._/-])(?:\d[ -]?){13,19}(?![A-Za-z0-9._/-])/g,
+        (m) => {
+            const digits = m.replace(/[^0-9]/g, "");
+            return digits.length >= 13 && digits.length <= 19 && luhn(digits) ? "[REDACTED_CC]" : m;
+        },
+    ],
+    // Bare long hex is usually a hash or a hex key, but a 40- or 64-character
+    // one introduced as a commit is a git object id — and "anchored to a
+    // commit" is how tier 2 is defined, so redacting it removes the anchor.
+    [
+        /\b[a-f0-9]{32,}\b/gi,
+        (m, offset, whole) => {
+            const gitLength = m.length === 40 || m.length === 64;
+            const lead = whole.slice(Math.max(0, offset - 28), offset).toLowerCase();
+            const introduced = /\b(commit|sha|rev|revision|head|tag|tree|blob|anchor|at)\b[^a-z0-9]*$/.test(lead);
+            return gitLength && introduced ? m : "[REDACTED_HEX]";
+        },
+    ],
 ];
 function redact(text) {
     if (!text || typeof text !== "string")

package/dist/mcp/server.js

@@ -32,6 +32,14 @@ const recall_1 = require("../lib/recall");
 const redact_1 = require("../lib/redact");
 const compose_1 = require("../lib/compose");
 const SUPPORTED_PROTOCOLS = ["2025-06-18", "2025-03-26", "2024-11-05"];
+function pkgVersion() {
+    try {
+        return require("../../package.json").version ?? "0.0.0";
+    }
+    catch {
+        return "0.0.0";
+    }
+}
 const TOOLS = [
     {
         name: "recall_memory",
@@ -182,7 +190,9 @@ function serve() {
                     respond(msg.id, {
                         protocolVersion: SUPPORTED_PROTOCOLS.includes(asked) ? asked : SUPPORTED_PROTOCOLS[0],
                         capabilities: { tools: {}, resources: {} },
-                        serverInfo: { name: "agentic-memory", version: "0.1.0" },
+                        // Read from the manifest rather than hardcoded: a pinned string
+                        // here drifts from the package version silently and forever.
+                        serverInfo: { name: "agentic-memory", version: pkgVersion() },
                     });
                 }
                 else if (msg.method === "ping") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "local-agentic-ai-mem",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Local-first memory for Claude Code. Your code and your memory never leave your machine.",
   "license": "MIT",
   "type": "commonjs",

package/templates/hooks/stop.mjs

@@ -39,7 +39,8 @@ async function main() {
   const { assignTier, gradeConfidence } = require(ROOT + '/dist/lib/tiers')
   const { redact } = require(ROOT + '/dist/lib/redact')
   const { openInjections, resolveInjection } = require(ROOT + '/dist/db')
-  const { readTranscript, scoreInjection } = require(ROOT + '/dist/lib/compliance')
+  const { readTranscript, scoreInjection, transcriptAfter } = require(ROOT + '/dist/lib/compliance')
+  const { significantFiles } = require(ROOT + '/dist/lib/files')
 
   const cwd = turn.cwd || p.cwd || process.cwd()
 
@@ -50,7 +51,11 @@ async function main() {
   if (p.transcript_path && existsSync(p.transcript_path)) {
     try {
       transcript = readFileSync(p.transcript_path, 'utf8')
-      extracted = extractMemory(transcript)
+      // Only this turn. extractMemory over the whole transcript re-mines every
+      // earlier turn, so a second prompt in the same session writes a near
+      // duplicate of the first turn's memory — two rows, both matching the
+      // prompt that produced them, both outranking real past work.
+      extracted = extractMemory(transcriptAfter(transcript, turn.started_at))
     } catch {}
   }
 
@@ -60,8 +65,13 @@ async function main() {
   if (transcript) {
     try {
       db(cwd)
-      const facts = readTranscript(transcript)
       for (const inj of openInjections(p.session_id)) {
+        // From the moment this memory was on screen. Scoring against the whole
+        // transcript counts words said before it was ever shown — and since
+        // memories are mined from the model's own output, that made echo
+        // unfalsifiable rather than weak. `at` is SQLite UTC without a zone.
+        const at = inj.at ? inj.at.replace(' ', 'T') + 'Z' : null
+        const facts = readTranscript(transcript, { after: at })
         resolveInjection(inj.id, scoreInjection({
           files: JSON.parse(inj.files || '[]'),
           tokens: JSON.parse(inj.tokens || '[]'),
@@ -72,7 +82,7 @@ async function main() {
   }
 
   const decisions = extracted?.decisions ?? []
-  const files = [...new Set([...(turn.files || []), ...(extracted?.files_touched ?? [])])]
+  const files = significantFiles([...(turn.files || []), ...(extracted?.files_touched ?? [])])
   const composed = extracted?.content
     ? { content: extracted.content, decisions }
     : composeAtomContent({ prompt: turn.prompt, decisions, files_touched: files, tool_calls: turn.tool_calls, git_commit: null })

package/templates/hooks/user-prompt-submit.mjs

@@ -12,7 +12,10 @@ const require = createRequire(import.meta.url)
 const ROOT = '__AGENTIC_MEMORY_ROOT__'
 
 const FILLER = /^(thanks|thank you|ok|okay|yes|go)\.?\??$/i
-const THRESHOLD = parseFloat(process.env.AGENTIC_MEMORY_THRESHOLD || '') || 0.35
+// Cosine, not the fused score. Measured on a real corpus: related queries peak
+// at 0.75-0.81, an off-topic question at 0.48, and the band that made memory
+// feel like noise sat at 0.59-0.60. 0.65 splits it with margin either side.
+const THRESHOLD = parseFloat(process.env.AGENTIC_MEMORY_THRESHOLD || '') || 0.65
 
 async function main() {
   let raw = ''
@@ -37,17 +40,28 @@ async function main() {
     const { distinctiveTokens } = require(ROOT + '/dist/lib/compliance')
     const { embed } = require(ROOT + '/dist/lib/embed')
     const { recall } = require(ROOT + '/dist/lib/recall')
+    const { significantFiles } = require(ROOT + '/dist/lib/files')
 
     db(cwd || process.cwd())
     const projectId = upsertProject(process.env.AGENTIC_MEMORY_PROJECT || basename(cwd || process.cwd()), cwd)
     const vec = await embed(prompt)
-    const hits = recall({ queryText: prompt, queryVec: vec, projectId, limit: 3 })
-    if (hits.length === 0 || hits[0].score < THRESHOLD * hits[0].score) return
+    const hits = recall({
+      queryText: prompt, queryVec: vec, projectId, limit: 3,
+      minSim: THRESHOLD,
+      // Memories this session wrote are this session's own output coming back.
+      excludeSessionId: session_id,
+    })
+    // Injecting nothing is a correct answer, and used to be unreachable: the
+    // guard here read `hits[0].score < THRESHOLD * hits[0].score`, which
+    // compares a number to a fraction of itself and is false for every
+    // positive score. Every prompt got the top 3 of whatever existed.
+    if (hits.length === 0) return
 
     const lines = ['<memory>', 'Relevant past work — use it, do not narrate it.', '']
     for (const h of hits) {
       lines.push(`• ${h.text}`)
-      if (h.files.length) lines.push(`  files: ${h.files.slice(0, 4).join(', ')}`)
+      const shown = significantFiles(h.files, 4)
+      if (shown.length) lines.push(`  files: ${shown.join(', ')}`)
     }
     lines.push('')
     lines.push('If the code in front of you disagrees, the code wins.')
@@ -55,8 +69,7 @@ async function main() {
 
     const text = lines.join('\n')
     try {
-      const files = []
-      for (const h of hits) for (const f of (h.files || [])) if (!files.includes(f)) files.push(f)
+      const files = significantFiles(hits.flatMap((h) => h.files || []))
       recordInjection({
         sessionId: session_id, projectId, kind: 'recall',
         memoryIds: hits.map((h) => h.id), files,