peon-mem 1.0.2 → 1.0.3

package/README.md

@@ -48,6 +48,7 @@ prompt. It runs as a daemon on your machine, and nothing leaves it.
 *The live monitor: 18k real beliefs rendered as stars. Type to make matching beliefs flare; click one to inspect it.*
 
 ![Search flare — type a query and matching beliefs light up across every galaxy](docs/assets/search-flare.gif)
+
 *Ask the field: typing "wulver cluster" makes 400+ matching beliefs flare while the rest dim, and the camera flies to them.*
 
 ## Why "Peon"?
@@ -80,6 +81,26 @@ The short version: mem0 and Zep are memory platforms for products you build. Peo
 for the coding agents you already use. It plugs into Claude Code or Codex in about five
 minutes, and you can watch it think and audit every number it claims.
 
+## Your agents share one brain
+
+If you run more than one coding agent — Claude Code and Codex, say — they usually each live in
+their own bubble. Whatever you work out with one is gone when you switch to the other.
+
+Point them at the same project and Peon dissolves that wall. Both agents resolve to the same
+`.peon/` brain (Peon canonicalizes the project path, so the hook, a direct MCP call, and Codex
+all land on one store). So the memory flows between them:
+
+- Codex works out how your build pipeline runs and records it. Next time you open Claude Code
+  in that repo, it's already in the injected context.
+- Claude Code hits a gotcha and files it. Codex sees it the moment it calls `get_context` or
+  `search_memory`.
+- The global brain sits above both, so your preferences and rules follow you into every agent,
+  in every project.
+
+They aren't chatting in real time. It's a shared notebook both write in and both read from, so
+a decision made in one agent shows up in the other without you re-explaining it. One project,
+one memory, however many agents.
+
 ## Quickstart
 
 Requirements: Node 20+, macOS or Linux. An [OpenRouter](https://openrouter.ai) API key is

package/dist/brain.js

@@ -53,12 +53,25 @@ export function resolveConflicts(records, now, protectGlobalScope = true) {
     // to active, loser archived (recoverable).
     const candidates = records.filter((r) => r.status === "active" || r.status === "conflicted");
     const conflicts = detectMemoryConflicts(candidates);
-    if (conflicts.length === 0)
-        return { records: [...records], actions: [] };
     const byId = new Map(records.map((r) => [r.id, r]));
     const archived = new Set();
     const reactivated = new Set();
     const actions = [];
+    // Every belief that is part of a CURRENTLY-detected conflict. Anything still flagged
+    // "conflicted" but not in this set is an orphan — the consolidator (or an older, looser
+    // detector) benched it, but it no longer collides with anything. Left alone it stays out of
+    // recall forever; the July→August backlog was 100+ such orphans. Reactivate them below.
+    const inLiveConflict = new Set();
+    for (const c of conflicts) {
+        inLiveConflict.add(c.leftId);
+        inLiveConflict.add(c.rightId);
+    }
+    for (const r of records) {
+        if (r.status === "conflicted" && !inLiveConflict.has(r.id)) {
+            reactivated.add(r.id);
+            actions.push({ type: "resolve_conflict", detail: `reactivated stale conflict flag on "${r.content.slice(0, 40)}"`, affectedIds: [r.id] });
+        }
+    }
     for (const conflict of conflicts) {
         const left = byId.get(conflict.leftId);
         const right = byId.get(conflict.rightId);

package/dist/entities.js

@@ -18,6 +18,25 @@
 const SRC_ROOTS = new Set(["src", "lib", "scripts", "test", "tests", "app", "apps", "packages", "dist", "bin"]);
 const FILE_EXT_RE = /\.(ts|tsx|js|jsx|mjs|cjs|json|md|mdx|html|css|scss|py|ipynb|pdf|txt|yml|yaml|toml|sh|sql|rs|go|java|rb|c|cpp|h)$/i;
 const IDENTIFIER_RE = /^[A-Za-z_$][\w$]*(?:[.#][A-Za-z_$][\w$]*)*$/;
+// Bare common words that are never useful DOMAIN entities. Without this gate a lowercase token
+// like "not" / "use" / "no" falls through the identifier branch and becomes a domain concept —
+// then two unrelated beliefs that merely both contain that word "share an entity" and get
+// false-flagged as conflicting. Only applies to plain lowercase words: file paths, product
+// acronyms (BIRD, DTS-SQL), and code symbols carry caps/digits/separators and never land here.
+const ENTITY_STOPWORDS = new Set([
+    "the", "this", "that", "these", "those", "a", "an", "it", "its", "we", "i", "you", "he", "she",
+    "they", "them", "our", "your", "their", "his", "her",
+    "if", "when", "then", "than", "for", "and", "but", "or", "nor", "so", "to", "in", "on", "of",
+    "at", "by", "as", "is", "are", "was", "were", "be", "been", "being", "do", "does", "did", "done",
+    "not", "no", "yes", "none", "null", "na", "nan", "true", "false",
+    "use", "used", "using", "avoid", "add", "added", "fix", "fixed", "make", "made", "set", "run",
+    "ran", "get", "got", "put", "new", "old", "now", "also", "with", "without", "from", "into",
+    "enable", "enabled", "disable", "disabled", "allow", "allowed", "deny", "forbidden",
+    "required", "optional", "about", "what", "which", "how", "why", "who", "where"
+]);
+function isEntityStopword(key) {
+    return ENTITY_STOPWORDS.has(key.toLowerCase());
+}
 /** Canonicalize one raw entity string. Returns null for junk (empty, too long, pure noise). */
 export function canonicalizeEntity(raw) {
     const s = (raw ?? "").trim().replace(/^[`'"]+|[`'"]+$/g, "").trim();
@@ -55,10 +74,15 @@ export function canonicalizeEntity(raw) {
             return { key: s.toLowerCase(), name: s, kind: "concept", namespace: "domain" };
         if (/[A-Z_]/.test(s.slice(1)))
             return { key: s, name: s, kind: "symbol", namespace: "code" };
-        // lowercase single token (e.g. "vllm", "ollama") — treat as a domain concept
+        // lowercase single token (e.g. "vllm", "ollama") — treat as a domain concept, unless it's a
+        // bare common word ("not", "use", "no") that would only create noise and false conflicts.
+        if (isEntityStopword(s))
+            return null;
         return { key: s.toLowerCase(), name: s, kind: "concept", namespace: "domain" };
     }
     // Multi-word phrase / proper noun → domain concept.
+    if (isEntityStopword(s))
+        return null;
     return { key: s.toLowerCase(), name: s, kind: "concept", namespace: "domain" };
 }
 // Common capitalized words that START sentences / clauses — not domain entities.

package/dist/global-memory.js

@@ -9,7 +9,12 @@ export class PeonGlobalMemoryStore {
         this.globalDir = globalDir;
     }
     static defaultDirectory() {
-        return PeonGlobalMemoryStore.defaultGlobalDir;
+        // PEON_GLOBAL_DIR relocates the global brain. Tests set it to a temp dir so they never read
+        // or write the real global store at ~/Library/Application Support/Peon/global — without this
+        // a tool created without an explicit globalMemoryDir falls back to the real store, which made
+        // cross-project isolation tests flaky and let test runs pollute the user's actual global brain.
+        const override = process.env.PEON_GLOBAL_DIR;
+        return override && override.trim() ? override.trim() : PeonGlobalMemoryStore.defaultGlobalDir;
     }
     static async open(options = {}) {
         const store = new PeonGlobalMemoryStore(options.globalDir ?? PeonGlobalMemoryStore.defaultDirectory());

package/dist/quality.js

@@ -37,6 +37,13 @@ export function detectMemoryConflicts(records) {
             const reason = opposingLanguageReason(left.content, right.content);
             if (!reason)
                 continue;
+            // Same-topic gate. A shared entity + one opposing word-pair somewhere in two long beliefs
+            // is a weak signal: on a research brain, dozens of beliefs all mention "BIRD" and one says
+            // "use X" while an unrelated one says "avoid Y". They don't contradict — they're just both
+            // about BIRD. Require the two beliefs to actually be discussing the same thing before
+            // calling it a conflict: several shared entities, or real content overlap beyond the token.
+            if (!sameTopic(left, right))
+                continue;
             conflicts.push({
                 entity,
                 leftId: left.id,
@@ -228,6 +235,47 @@ function sharedEntity(left, right) {
     }
     return undefined;
 }
+const TOPIC_STOP = new Set([
+    "the", "a", "an", "and", "or", "but", "to", "of", "in", "on", "for", "with", "is", "are", "was",
+    "were", "be", "as", "at", "by", "it", "this", "that", "we", "our", "use", "used", "using", "from",
+    "not", "no", "yes", "do", "does", "did", "so", "if", "then", "than", "when", "which", "what"
+]);
+/** Content tokens (lowercased, ≥3 chars, minus stopwords) — the topical fingerprint of a belief. */
+function contentTokens(text) {
+    const out = new Set();
+    for (const raw of (text ?? "").toLowerCase().split(/[^a-z0-9]+/)) {
+        if (raw.length >= 3 && !TOPIC_STOP.has(raw))
+            out.add(raw);
+    }
+    return out;
+}
+/**
+ * True when two beliefs are actually discussing the same thing — the precondition for their
+ * opposing language to be a real contradiction rather than a coincidence. Satisfied by either
+ * multiple shared entities (a strong same-subject signal) or meaningful content overlap
+ * (Jaccard of content tokens above a floor). Prevents "both mention BIRD, one says use / one
+ * says avoid, about unrelated things" from being flagged.
+ */
+function sameTopic(left, right) {
+    const le = new Set(left.entities.map(normalizeEntity));
+    const re = new Set(right.entities.map(normalizeEntity));
+    let sharedEntities = 0;
+    for (const e of le)
+        if (re.has(e))
+            sharedEntities += 1;
+    if (sharedEntities >= 2)
+        return true;
+    const lt = contentTokens(left.content);
+    const rt = contentTokens(right.content);
+    if (lt.size === 0 || rt.size === 0)
+        return false;
+    let inter = 0;
+    for (const t of lt)
+        if (rt.has(t))
+            inter += 1;
+    const jaccard = inter / (lt.size + rt.size - inter);
+    return jaccard >= 0.25;
+}
 function opposingLanguageReason(left, right) {
     const leftText = normalizeMemory(left);
     const rightText = normalizeMemory(right);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "peon-mem",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "type": "module",
   "main": "dist/index.js",
   "bin": {
@@ -21,7 +21,7 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.23.0"
   },
-  "description": "Local-first hierarchical memory brain for AI coding agents \u2014 auto-capture, LLM consolidation into beliefs, hybrid retrieval, per-prompt injection, a living Neural Universe monitor, and a daily self-improvement loop. Works with Claude Code, Codex, and any MCP client.",
+  "description": "Local-first hierarchical memory brain for AI coding agents — auto-capture, LLM consolidation into beliefs, hybrid retrieval, per-prompt injection, a living Neural Universe monitor, and a daily self-improvement loop. Works with Claude Code, Codex, and any MCP client.",
   "license": "MIT",
   "keywords": [
     "memory",
@@ -55,4 +55,4 @@
     "LICENSE"
   ],
   "mcpName": "io.github.VineetV2/peon-mem"
-}
+}