peon-mem 1.0.2 → 1.0.4

package/README.md

@@ -1,6 +1,6 @@
 # 🧠 Peon — a memory brain for your AI coding agents
 
-[![npm](https://img.shields.io/npm/v/peon-mem)](https://www.npmjs.com/package/peon-mem) [![license](https://img.shields.io/badge/license-MIT-blue)](LICENSE) [![tests](https://img.shields.io/badge/tests-passing-brightgreen)](test/)
+[![npm](https://img.shields.io/npm/v/peon-mem)](https://www.npmjs.com/package/peon-mem) [![downloads](https://img.shields.io/npm/dm/peon-mem)](https://www.npmjs.com/package/peon-mem) [![license](https://img.shields.io/badge/license-MIT-blue)](LICENSE) [![tests](https://img.shields.io/badge/tests-passing-brightgreen)](test/) [![MCP Registry](https://img.shields.io/badge/MCP%20Registry-listed-6b4fbb)](https://registry.modelcontextprotocol.io) [![Star on GitHub](https://img.shields.io/github/stars/VineetV2/peon-mem?style=social)](https://github.com/VineetV2/peon-mem)
 
 **Local-first, hierarchical, self-improving memory for Claude Code, Codex, and any MCP client.**
 
@@ -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
@@ -412,3 +433,12 @@ or send a PR directly.
 Rules of the house: every retrieval/quality change ships with a test and an eval-ledger run
 (`npm run eval`); negative results get documented, not deleted; nothing may hard-delete user
 memory. `npm test` must stay green.
+
+---
+
+<div align="center">
+
+**If Peon is useful to you, [★ star it on GitHub](https://github.com/VineetV2/peon-mem)** — it is
+how other people building with coding agents find it.
+
+</div>

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/monitor.js

@@ -58,6 +58,8 @@ const CLIENT_SCRIPT = String.raw `
 
   function esc(v){ return String(v==null?"":v).replace(/[&<>"']/g,function(c){return {"&":"&amp;","<":"&lt;",">":"&gt;",'"':"&quot;","'":"&#39;"}[c];}); }
   function clip(v,n){ var s=String(v==null?"":v).trim(); return s.length>n?s.slice(0,n)+"…":s; }
+  // "summary" → "summaries", "fact" → "facts". Belief type names are user-visible in search results.
+  function plural(w,n){ if(n===1) return w; return /(s|x|z|ch|sh)$/.test(w)?w+"es":/[^aeiou]y$/.test(w)?w.slice(0,-1)+"ies":w+"s"; }
   function fmt(n){ return (Number(n)||0).toLocaleString("en-US"); }
   function tm(iso){ try{ return new Date(iso).toLocaleTimeString([], {hour:"2-digit",minute:"2-digit",second:"2-digit"}); }catch(e){ return ""; } }
   function name(p){ return String(p||"").split("/").filter(Boolean).pop()||"project"; }
@@ -316,6 +318,96 @@ const CLIENT_SCRIPT = String.raw `
     UNI.hits=set;
     if(hitsEl) hitsEl.textContent=m?(m+" MATCH"+(m>1?"ES":"")):"NO MATCH";
     if(m){ UNI.tx.x=sx/m; UNI.tx.y=sy/m; UNI.tx.z=Math.max(UNI.cam.z, m<20?1.1:0.55); }
+    uniResults(q, toks);
+  }
+
+  /* Readable answer for a query: an EXTRACTIVE summary (no model call — works with AI off) plus
+     the ranked hits. Flaring stars tell you a match exists; this tells you what it says. */
+  function uniResults(q, toks){
+    var el=EL("uni-results"); if(!el) return;
+    if(!q||!UNI.hits||!UNI.hits.size){ el.hidden=true; el.innerHTML=""; return; }
+    // Dedupe by record id: the same belief can be drawn as more than one star (a global belief
+    // also appears under a project galaxy), and counting/listing it twice would misreport memory.
+    var seen={}, hits=[];
+    UNI.nodes.forEach(function(n){
+      if(!UNI.hits.has(n.id)||seen[n.id]) return;
+      seen[n.id]=1; hits.push(n);
+    });
+    // Rank: query-term density, then belief strength/importance, then recency.
+    hits.forEach(function(n){
+      var hay=(n.rec.content+" "+(n.rec.entities||[]).join(" ")).toLowerCase(), d=0;
+      toks.forEach(function(t){ var i=0; while((i=hay.indexOf(t,i))>=0){ d++; i+=t.length; } });
+      var imp=(n.rec.score&&n.rec.score.importance)||0;
+      n._r=d*2 + imp*3 + (n.rec.strength||0) + (n.rec.recallCount||0)*0.2;
+      // Current truth outranks history: a superseded/archived phrasing must never sit above the
+      // active belief that replaced it (same reasoning as stale-shadow demotion in retrieval).
+      if(n.rec.status&&n.rec.status!=="active") n._r-=6;
+      if(n.rec.pinned) n._r+=3;
+      // Prefer beliefs that ANSWER the question over pointers to where an answer lives: a bare
+      // file path matching on its filename is not a summary. Prose types lead; paths sink.
+      var c=n.rec.content||"";
+      var pathish=/^[~/.]|^[A-Za-z]:\\/.test(c.trim()) && c.trim().split(/\s+/).length<=3;
+      if(pathish) n._r-=4;
+      if(n.rec.type==="decision"||n.rec.type==="fact"||n.rec.type==="preference") n._r+=1.5;
+    });
+    hits.sort(function(a,b){ return b._r-a._r; });
+
+    // Facets: what KIND of memory answered, and where it lives.
+    var byType={}, byProj={}, ents={}, oldest=null, newest=null;
+    hits.forEach(function(n){
+      var r=n.rec;
+      byType[r.type]=(byType[r.type]||0)+1;
+      byProj[n.cl.name]=(byProj[n.cl.name]||0)+1;
+      (r.entities||[]).forEach(function(e){ ents[e]=(ents[e]||0)+1; });
+      var t=r.updatedAt||r.createdAt;
+      if(t){ if(!oldest||t<oldest) oldest=t; if(!newest||t>newest) newest=t; }
+    });
+    var topEnts=Object.keys(ents).sort(function(a,b){ return ents[b]-ents[a]; }).slice(0,6);
+    var typeStr=Object.keys(byType).sort(function(a,b){ return byType[b]-byType[a]; })
+      .map(function(t){ return byType[t]+" "+plural(t.replace(/_/g," "),byType[t]); }).join(" · ");
+    var projStr=Object.keys(byProj).sort(function(a,b){ return byProj[b]-byProj[a]; }).slice(0,3).join(", ");
+
+    // The summary line: the single strongest belief, verbatim, plus the shape of the rest.
+    // Beliefs recorded against a file often read "<absolute path>: <the actual point>" — the path
+    // is provenance (kept in the hit list), so lead with the point instead of the filename.
+    var lead=String(hits[0].rec.content||"").replace(/^\s*[~/][^\s:]{12,}:\s*/,"");
+    var summary='<b>'+esc(clip(lead,260))+'</b>';
+    if(hits.length>1) summary+='<br><span style="color:var(--muted)">+ '+(hits.length-1)+' more across '+esc(projStr)+
+      (newest?', last updated '+esc(ago(newest)):'')+'.</span>';
+
+    var facets='<span class="ur-facet">'+esc(typeStr)+'</span>'+
+      topEnts.map(function(e){ return '<span class="ur-facet">'+esc(e)+'</span>'; }).join("");
+
+    var SHOW=12;
+    var list=hits.slice(0,SHOW).map(function(n,i){
+      var r=n.rec, meta=[];
+      if(r.status&&r.status!=="active") meta.push(r.status);
+      meta.push(n.cl.name);
+      if(r.recallCount) meta.push("recalled "+r.recallCount+"×");
+      if(r.updatedAt) meta.push(ago(r.updatedAt));
+      return '<button class="ur-hit" data-i="'+i+'">'+
+        '<div class="h-t" style="color:'+n.c+'">'+esc(r.type)+'</div>'+
+        esc(clip(r.content,180))+
+        '<div class="h-m">'+esc(meta.join(" · "))+'</div></button>';
+    }).join("");
+
+    el.hidden=false;
+    el.innerHTML='<button class="ui-x" id="ur-x">✕</button>'+
+      '<div class="ur-head">'+hits.length+' belief'+(hits.length>1?"s":"")+' answer "'+esc(clip(q,40))+'"</div>'+
+      '<div class="ur-sum">'+summary+'</div>'+
+      '<div class="ur-facets">'+facets+'</div>'+
+      '<div class="ur-list">'+list+'</div>'+
+      (hits.length>SHOW?'<div class="ur-more">showing top '+SHOW+' of '+hits.length+'</div>':"");
+
+    var x=EL("ur-x"); if(x) x.addEventListener("click",function(){ el.hidden=true; });
+    Array.prototype.forEach.call(el.querySelectorAll(".ur-hit"),function(b){
+      b.addEventListener("click",function(){
+        var n=hits[Number(b.getAttribute("data-i"))];
+        if(!n) return;
+        uniInspect(n);                                   // full detail + provenance
+        UNI.tx.x=n.x; UNI.tx.y=n.y; UNI.tx.z=Math.max(1.6,UNI.cam.z);  // fly to the star
+      });
+    });
   }
   function uniInspect(n){
     var el=EL("uni-inspect"); if(!el) return;
@@ -329,7 +421,19 @@ const CLIENT_SCRIPT = String.raw `
         '<span class="g">IMP <b>'+pct(r.score&&r.score.importance)+'</b><i class="bar"><i style="width:'+pct(r.score&&r.score.importance)+'%"></i></i></span>'+
         '<span class="g">CONF <b>'+pct(r.score&&r.score.confidence)+'</b><i class="bar"><i class="b2" style="width:'+pct(r.score&&r.score.confidence)+'%"></i></i></span></div>'+
       ((r.entities&&r.entities.length)?'<div class="ui-ents">'+r.entities.slice(0,8).map(function(e){return '<span class="ent mono">'+esc(e)+'</span>';}).join("")+'</div>':"")+
-      '<div class="ui-proj mono">'+esc(n.cl.name)+(r.updatedAt?' · '+esc(ago(r.updatedAt)):'')+'</div>'+
+      // Provenance: where this belief came from and how it has been used. Answers "why does my
+      // agent believe this, and is it still current?" without opening the JSONL by hand.
+      '<div class="ui-proj mono">'+(function(){
+        var p=[];
+        if(r.createdAt) p.push("learned "+ago(r.createdAt));
+        if(r.updatedAt&&r.updatedAt!==r.createdAt) p.push("updated "+ago(r.updatedAt));
+        if(r.recallCount) p.push("recalled "+r.recallCount+"×"+(r.lastRecalledAt?" (last "+ago(r.lastRecalledAt)+")":""));
+        if(r.pinned) p.push("pinned");
+        if(r.summarizedBy) p.push("folded into a summary");
+        if(r.source&&r.source.reason) p.push("via "+clip(r.source.reason,48));
+        if(r.provenance&&r.provenance.ref) p.push("source: "+clip(r.provenance.ref,44));
+        return esc(n.cl.name)+(p.length?' · '+esc(p.join(" · ")):'');
+      })()+'</div>'+
       (n.cl.path?'<button class="btn sm" id="ui-open">OPEN IN MEMORY BANKS →</button>':"");
     var x=EL("ui-x"); if(x) x.addEventListener("click",function(){ uniInspect(null); });
     var op=EL("ui-open"); if(op) op.addEventListener("click",function(){
@@ -873,6 +977,26 @@ const DOCUMENT = String.raw `<!doctype html>
   .ui-meta{display:flex; gap:14px; margin-bottom:9px;}
   .ui-ents{display:flex; flex-wrap:wrap; gap:5px; margin-bottom:10px;}
   .ui-proj{color:var(--faint); font-size:10px; margin-bottom:11px;}
+  /* Search RESULTS panel (right side, mirrors .uni-inspect on the left): the readable answer to
+     a query — an extractive summary of what memory says, then the ranked hits you can click. */
+  .uni-results{position:absolute; top:60px; right:14px; z-index:8; width:360px; max-height:calc(100% - 130px); overflow:auto;
+    background:linear-gradient(165deg, rgba(8,26,42,.96), rgba(4,14,26,.96)); border:1px solid var(--cyan); clip-path:var(--cham);
+    padding:16px; box-shadow:0 0 34px -8px rgba(89,227,255,.5);}
+  .ur-head{font-family:var(--mono); font-size:10px; letter-spacing:.18em; text-transform:uppercase; color:var(--cyan);
+    margin-bottom:10px; text-shadow:0 0 10px rgba(89,227,255,.6);}
+  .ur-sum{font-size:12px; line-height:1.6; color:var(--ink); border-left:2px solid var(--cyan);
+    padding:2px 0 2px 10px; margin-bottom:12px;}
+  .ur-sum b{color:var(--cyan-ink);}
+  .ur-facets{display:flex; flex-wrap:wrap; gap:5px; margin-bottom:12px;}
+  .ur-facet{font-family:var(--mono); font-size:9.5px; letter-spacing:.08em; text-transform:uppercase;
+    border:1px solid rgba(89,227,255,.35); color:var(--muted); padding:2px 6px; clip-path:var(--cham);}
+  .ur-list{display:flex; flex-direction:column; gap:7px;}
+  .ur-hit{text-align:left; width:100%; background:rgba(6,20,34,.7); border:1px solid rgba(89,227,255,.18);
+    padding:8px 10px; clip-path:var(--cham); cursor:pointer; color:var(--ink); font-size:11.5px; line-height:1.5;}
+  .ur-hit:hover{border-color:var(--cyan); background:rgba(10,30,48,.9);}
+  .ur-hit .h-t{font-family:var(--mono); font-size:9px; letter-spacing:.12em; text-transform:uppercase; color:var(--cyan); margin-bottom:3px;}
+  .ur-hit .h-m{font-family:var(--mono); font-size:9px; color:var(--faint); margin-top:4px;}
+  .ur-more{font-family:var(--mono); font-size:9.5px; color:var(--faint); margin-top:9px; text-align:center;}
   .uni-ticker{position:absolute; left:0; right:0; bottom:0; z-index:6; padding:8px 16px 10px;
     background:linear-gradient(180deg, transparent, rgba(2,8,16,.9) 40%); font-family:var(--mono); font-size:10px; color:var(--muted);}
   .utk{padding:2px 0; white-space:nowrap; overflow:hidden; text-overflow:ellipsis;}
@@ -918,6 +1042,7 @@ const DOCUMENT = String.raw `<!doctype html>
       <div class="uni-legend" id="uni-legend"></div>
       <div class="uni-tip mono" id="uni-tip" hidden></div>
       <div class="uni-inspect" id="uni-inspect" hidden></div>
+      <div class="uni-results" id="uni-results" hidden></div>
       <div class="uni-ticker" id="uni-ticker"></div>
     </div>
     <div id="bh-body"></div>

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.4",
   "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"
-}
+}