peon-mem 1.0.6 → 1.0.8

package/dist/quality.d.ts

@@ -77,7 +77,23 @@ export interface SerializedMemoryQualityReport {
     audit: MemoryQualityAuditSummary;
 }
 export declare function deduplicateMemoryRecords(records: MemoryRecord[]): DeduplicateMemoryRecordsResult;
-export declare function detectMemoryConflicts(records: MemoryRecord[]): MemoryConflict[];
+export interface DetectConflictOptions {
+    /** Compare every pair (the original scan). Kept for equivalence testing. */
+    exhaustive?: boolean;
+    /** Override the ubiquitous-entity bucket cap (default MAX_ENTITY_BUCKET). */
+    maxEntityBucket?: number;
+}
+/** How many record pairs the last scan actually string-compared. */
+export declare function conflictScanStats(): {
+    pairsEvaluated: number;
+};
+/**
+ * Conflicts require a shared entity, so only pairs that co-occur in some entity's
+ * bucket can ever qualify. Indexing by entity skips the overwhelming majority of
+ * pairs without touching a string; everything derived per record (normalized text,
+ * token sets, entity maps) is computed once instead of once per pair.
+ */
+export declare function detectMemoryConflicts(records: MemoryRecord[], options?: DetectConflictOptions): MemoryConflict[];
 export declare function markStaleMemoryRecords(records: MemoryRecord[], options?: StaleMemoryOptions): MarkStaleMemoryRecordsResult;
 export declare function promoteMemoryRecords(records: MemoryRecord[], options?: PromoteMemoryRecordsOptions): PromoteMemoryRecordsResult;
 export declare function applyMemoryQualityReport(records: MemoryRecord[], report: MemoryQualityReport): ApplyMemoryQualityReportResult;

package/dist/quality.js

@@ -25,34 +25,161 @@ export function deduplicateMemoryRecords(records) {
         duplicates
     };
 }
-export function detectMemoryConflicts(records) {
-    const conflicts = [];
-    for (let leftIndex = 0; leftIndex < records.length; leftIndex += 1) {
-        for (let rightIndex = leftIndex + 1; rightIndex < records.length; rightIndex += 1) {
-            const left = records[leftIndex];
-            const right = records[rightIndex];
-            const entity = sharedEntity(left, right);
-            if (!entity)
-                continue;
-            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))
+/**
+ * An entity attached to more records than this is not evidence that two beliefs are
+ * about the same thing — on a research brain "peon" or "BIRD" appears on thousands of
+ * records, and pairing them all is what made this scan quadratic. Such buckets are
+ * skipped; a conflict between two beliefs whose ONLY link is a ubiquitous tag is
+ * exactly the false positive the same-topic gate already exists to suppress.
+ */
+const MAX_ENTITY_BUCKET = Number(process.env.PEON_CONFLICT_MAX_ENTITY_BUCKET) > 0
+    ? Number(process.env.PEON_CONFLICT_MAX_ENTITY_BUCKET)
+    : 2000;
+const OPPOSING_WORD_PAIRS = [
+    ["enabled", "disabled", "opposing enabled/disabled language"],
+    ["enable", "disable", "opposing enable/disable language"],
+    ["allowed", "forbidden", "opposing allowed/forbidden language"],
+    ["allow", "deny", "opposing allow/deny language"],
+    ["required", "optional", "opposing required/optional language"],
+    ["true", "false", "opposing true/false language"],
+    ["yes", "no", "opposing yes/no language"],
+    ["use", "avoid", "opposing use/avoid language"]
+];
+let lastPairsEvaluated = 0;
+/** How many record pairs the last scan actually string-compared. */
+export function conflictScanStats() {
+    return { pairsEvaluated: lastPairsEvaluated };
+}
+function prepareForConflicts(records) {
+    return records.map((record) => {
+        const entityPairs = record.entities.map((entity) => [normalizeEntity(entity), entity]);
+        const entityByNormalized = new Map();
+        // Later duplicates lose, matching the original Map-from-entries behaviour.
+        for (const [normalized, original] of entityPairs)
+            entityByNormalized.set(normalized, original);
+        const text = normalizeMemory(record.content);
+        return {
+            record,
+            entityPairs,
+            entityByNormalized,
+            normalizedEntities: new Set(entityPairs.map(([normalized]) => normalized)),
+            words: new Set(text.split(" ").filter(Boolean)),
+            topicTokens: contentTokens(record.content)
+        };
+    });
+}
+function sharedEntityOf(left, right) {
+    for (const [normalized, original] of left.entityPairs) {
+        const match = right.entityByNormalized.get(normalized);
+        if (match)
+            return original.trim() || match;
+    }
+    return undefined;
+}
+/**
+ * Word presence via the precomputed token set. normalizeMemory() strips punctuation
+ * and collapses whitespace, so the old `(^|\s)word($|\s)` regex was exactly a test
+ * for "word is a whitespace-delimited token" — a Set lookup is equivalent, without
+ * building a RegExp per check.
+ */
+function opposingReasonOf(left, right) {
+    for (const [positive, negative, reason] of OPPOSING_WORD_PAIRS) {
+        if (left.words.has(positive) && right.words.has(negative))
+            return reason;
+        if (left.words.has(negative) && right.words.has(positive))
+            return reason;
+    }
+    return undefined;
+}
+function sameTopicOf(left, right) {
+    let sharedEntities = 0;
+    for (const entity of left.normalizedEntities)
+        if (right.normalizedEntities.has(entity))
+            sharedEntities += 1;
+    if (sharedEntities >= 2)
+        return true;
+    if (left.topicTokens.size === 0 || right.topicTokens.size === 0)
+        return false;
+    let intersection = 0;
+    for (const token of left.topicTokens)
+        if (right.topicTokens.has(token))
+            intersection += 1;
+    const jaccard = intersection / (left.topicTokens.size + right.topicTokens.size - intersection);
+    return jaccard >= 0.25;
+}
+/**
+ * Conflicts require a shared entity, so only pairs that co-occur in some entity's
+ * bucket can ever qualify. Indexing by entity skips the overwhelming majority of
+ * pairs without touching a string; everything derived per record (normalized text,
+ * token sets, entity maps) is computed once instead of once per pair.
+ */
+export function detectMemoryConflicts(records, options = {}) {
+    const prepared = prepareForConflicts(records);
+    const found = [];
+    let pairsEvaluated = 0;
+    const evaluate = (leftIndex, rightIndex) => {
+        pairsEvaluated += 1;
+        const left = prepared[leftIndex];
+        const right = prepared[rightIndex];
+        const entity = sharedEntityOf(left, right);
+        if (!entity)
+            return;
+        const reason = opposingReasonOf(left, right);
+        if (!reason)
+            return;
+        // 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 (!sameTopicOf(left, right))
+            return;
+        found.push({
+            leftIndex,
+            rightIndex,
+            conflict: { entity, leftId: left.record.id, rightId: right.record.id, reason }
+        });
+    };
+    if (options.exhaustive) {
+        for (let leftIndex = 0; leftIndex < prepared.length; leftIndex += 1) {
+            for (let rightIndex = leftIndex + 1; rightIndex < prepared.length; rightIndex += 1) {
+                evaluate(leftIndex, rightIndex);
+            }
+        }
+    }
+    else {
+        const byEntity = new Map();
+        for (let index = 0; index < prepared.length; index += 1) {
+            for (const entity of prepared[index].normalizedEntities) {
+                const bucket = byEntity.get(entity);
+                if (bucket)
+                    bucket.push(index);
+                else
+                    byEntity.set(entity, [index]);
+            }
+        }
+        const seen = new Set();
+        const width = prepared.length;
+        for (const bucket of byEntity.values()) {
+            if (bucket.length > (options.maxEntityBucket ?? MAX_ENTITY_BUCKET))
                 continue;
-            conflicts.push({
-                entity,
-                leftId: left.id,
-                rightId: right.id,
-                reason
-            });
+            for (let a = 0; a < bucket.length; a += 1) {
+                for (let b = a + 1; b < bucket.length; b += 1) {
+                    const leftIndex = bucket[a];
+                    const rightIndex = bucket[b];
+                    const key = leftIndex * width + rightIndex;
+                    if (seen.has(key))
+                        continue;
+                    seen.add(key);
+                    evaluate(leftIndex, rightIndex);
+                }
+            }
         }
+        // Restore the original left-to-right emission order.
+        found.sort((x, y) => x.leftIndex - y.leftIndex || x.rightIndex - y.rightIndex);
     }
-    return conflicts;
+    lastPairsEvaluated = pairsEvaluated;
+    return found.map((entry) => entry.conflict);
 }
 export function markStaleMemoryRecords(records, options = {}) {
     const now = options.now ?? new Date();

package/dist/recuration.js

@@ -1,7 +1,8 @@
+import { llmEnabled, llmEndpoint, llmHeaders } from "./config.js";
 const BATCH_SIZE = 30;
 const PER_BATCH_MAX_FRACTION = 0.4; // a batch that wants to drop more than this is misjudging — skip it
 export function createRecurator(config) {
-    if (config.aiMode === "off" || !config.openRouterApiKey)
+    if (!llmEnabled(config))
         return null;
     return async (records) => {
         const active = records.filter((r) => r.status === "active" && !r.pinned);
@@ -33,9 +34,9 @@ async function judgeBatch(config, batch) {
         "KEEP every decision, result/metric, preference, file, and open question unless it is pure setup-action noise. " +
         "You should typically remove only a small fraction; removing most beliefs is WRONG. When in any doubt, KEEP. " +
         "Output ONLY a JSON array of the ids to remove — no fences, no prose. If none, return [].";
-    const response = await fetch("https://openrouter.ai/api/v1/chat/completions", {
+    const response = await fetch(llmEndpoint(config), {
         method: "POST",
-        headers: { Authorization: `Bearer ${config.openRouterApiKey}`, "Content-Type": "application/json" },
+        headers: llmHeaders(config),
         body: JSON.stringify({
             model: config.processingModel,
             messages: [

package/dist/reranker.js

@@ -1,3 +1,4 @@
+import { llmEnabled, llmEndpoint } from "./config.js";
 const DEFAULT_TOP_K = 20;
 const DEFAULT_SNIPPET_CHARS = 240;
 export async function rerankRecords(query, records, options) {
@@ -6,7 +7,7 @@ export async function rerankRecords(query, records, options) {
     // Cheap exits — never pay an LLM call when it cannot help.
     if (!q || records.length < 2)
         return records;
-    if (config.aiMode === "off" || !config.openRouterApiKey)
+    if (!llmEnabled(config))
         return records;
     const topK = Math.max(2, Math.trunc(options.topK ?? DEFAULT_TOP_K));
     const snippetChars = Math.max(40, Math.trunc(options.snippetChars ?? DEFAULT_SNIPPET_CHARS));
@@ -24,10 +25,10 @@ export async function rerankRecords(query, records, options) {
         "Include every number exactly once. No prose, no code fences.";
     const user = `Query: ${q}\n\nCandidates:\n${numbered}\n\nJSON array of numbers (most relevant first):`;
     try {
-        const response = await doFetch("https://openrouter.ai/api/v1/chat/completions", {
+        const response = await doFetch(llmEndpoint(config), {
             method: "POST",
             headers: {
-                Authorization: `Bearer ${config.openRouterApiKey}`,
+                Authorization: `Bearer ${config.llmApiKey ?? config.openRouterApiKey ?? ""}`,
                 "Content-Type": "application/json"
             },
             body: JSON.stringify({

package/dist/tools.d.ts

@@ -229,4 +229,8 @@ export interface PeonTools {
     processMemory(input: ProcessMemoryToolInput): Promise<ProcessMemoryResult>;
     maybeProcessMemory(input: MaybeProcessMemoryToolInput): Promise<MaybeProcessMemoryResult>;
 }
+/** How many project stores are currently held open. */
+export declare function openStoreCacheStats(): {
+    openStores: number;
+};
 export declare function createPeonTools(options?: CreatePeonToolsOptions): PeonTools;

package/dist/tools.js

@@ -14,6 +14,20 @@ import { createRecurator } from "./recuration.js";
 import { evaluatePeonProject } from "./evaluation.js";
 import { buildContextInjection } from "./injection.js";
 import { SessionIndex } from "./session-index.js";
+/**
+ * Open memory stores are cached per project so repeated calls don't reopen a brain.
+ * Left unbounded, every project the daemon ever touched stayed resident — and each
+ * store carries an EmbeddingStore whose sidecar cache holds real memory. Bound it:
+ * an evicted project simply reopens on next use, which costs one open, not accuracy.
+ */
+const MAX_OPEN_STORES = Number(process.env.PEON_MAX_OPEN_STORES) > 0
+    ? Number(process.env.PEON_MAX_OPEN_STORES)
+    : 4;
+let openStoreCount = 0;
+/** How many project stores are currently held open. */
+export function openStoreCacheStats() {
+    return { openStores: openStoreCount };
+}
 export function createPeonTools(options = {}) {
     if (options.daemonUrl) {
         return createDaemonBackedTools(options.daemonUrl);
@@ -23,10 +37,22 @@ export function createPeonTools(options = {}) {
     let globalStorePromise;
     async function storeFor(projectPath) {
         const existing = storesByProject.get(projectPath);
-        if (existing)
+        if (existing) {
+            // Re-insert so Map iteration order stays least-recently-used first.
+            storesByProject.delete(projectPath);
+            storesByProject.set(projectPath, existing);
+            openStoreCount = storesByProject.size;
             return existing;
+        }
         const store = await PeonMemoryStore.open({ projectPath });
         storesByProject.set(projectPath, store);
+        while (storesByProject.size > MAX_OPEN_STORES) {
+            const oldest = storesByProject.keys().next().value;
+            if (oldest === undefined)
+                break;
+            storesByProject.delete(oldest);
+        }
+        openStoreCount = storesByProject.size;
         return store;
     }
     async function storeForSession(sessionId) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "peon-mem",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "type": "module",
   "main": "dist/index.js",
   "bin": {
@@ -19,7 +19,7 @@
     "prepublishOnly": "npm run build && npm test"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.23.0"
+    "@modelcontextprotocol/sdk": "^1.29.0"
   },
   "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",
@@ -43,7 +43,7 @@
   },
   "devDependencies": {
     "typescript": "^5.7.0",
-    "vitest": "^4.0.0",
+    "vitest": "^4.1.11",
     "@types/node": "^22.0.0"
   },
   "files": [

package/scripts/peon-operations-watch.mjs

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+/**
+ * Is the consolidation model actually REVISING beliefs, or only appending them?
+ *
+ * Peon's value rests on supersede/obsolete operations — the difference between a
+ * brain and a filing cabinet. A model that emits none still looks healthy: runs
+ * succeed, records accumulate, nothing errors. This reads the daemon log and reports
+ * per-model rates so a regression is visible instead of inferred.
+ *
+ * Usage: node scripts/peon-operations-watch.mjs [--since 2026-09-09] [--json]
+ */
+import { readFileSync, readdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+const LOG_DIR = join(homedir(), "Library", "Logs", "Peon");
+const args = process.argv.slice(2);
+const since = (args[args.indexOf("--since") + 1] || "").match(/^\d{4}-\d{2}-\d{2}/) ? args[args.indexOf("--since") + 1] : null;
+const asJson = args.includes("--json");
+
+const files = readdirSync(LOG_DIR).filter((f) => f.startsWith("daemon.jsonl")).map((f) => join(LOG_DIR, f));
+const runs = [];
+for (const file of files) {
+  let text = "";
+  try { text = readFileSync(file, "utf8"); } catch { continue; }
+  for (const line of text.split("\n")) {
+    if (!line.includes("process_finish")) continue;
+    let entry;
+    try { entry = JSON.parse(line); } catch { continue; }
+    if (!/^(auto_)?process_finish$/.test(entry.type ?? "")) continue;
+    if (entry.status !== "processed") continue;
+    if (since && (entry.createdAt ?? "") < since) continue;
+    runs.push(entry);
+  }
+}
+runs.sort((a, b) => String(a.createdAt).localeCompare(String(b.createdAt)));
+
+const byModel = new Map();
+for (const r of runs) {
+  const key = r.model ?? "unknown";
+  const a = byModel.get(key) ?? { runs: 0, operationsEmitted: 0, superseded: 0, obsoleted: 0, recordsAdded: 0, merged: 0, first: r.createdAt, last: r.createdAt };
+  a.runs += 1;
+  for (const k of ["operationsEmitted", "superseded", "obsoleted", "recordsAdded", "merged"]) a[k] += Number(r[k] ?? 0);
+  a.last = r.createdAt;
+  byModel.set(key, a);
+}
+
+const report = [...byModel.entries()].map(([model, a]) => ({
+  model,
+  runs: a.runs,
+  opsPerRun: +(a.operationsEmitted / a.runs).toFixed(2),
+  supersededPerRun: +(a.superseded / a.runs).toFixed(2),
+  addedPerRun: +(a.recordsAdded / a.runs).toFixed(2),
+  mergedPerRun: +(a.merged / a.runs).toFixed(2),
+  totals: { ...a, first: undefined, last: undefined },
+  window: `${String(a.first).slice(0, 19)} .. ${String(a.last).slice(0, 19)}`
+}));
+
+if (asJson) { console.log(JSON.stringify({ generatedAt: new Date().toISOString(), since, report }, null, 2)); process.exit(0); }
+
+console.log(`Peon consolidation quality — ${new Date().toISOString().slice(0, 19)}Z${since ? ` (since ${since})` : ""}`);
+console.log(`total consolidations: ${runs.length}\n`);
+console.log("  model                             runs   ops/run  superseded/run  added/run  merged/run");
+for (const r of report.sort((a, b) => b.runs - a.runs)) {
+  console.log(
+    `  ${r.model.padEnd(32).slice(0, 32)} ${String(r.runs).padStart(5)}  ${String(r.opsPerRun).padStart(7)}  ${String(r.supersededPerRun).padStart(14)}  ${String(r.addedPerRun).padStart(9)}  ${String(r.mergedPerRun).padStart(10)}`
+  );
+}
+const local = report.find((r) => !r.model.includes("/") && r.model !== "manual-ai-result" && r.model !== "unknown");
+if (local) {
+  console.log();
+  if (local.runs < 10) {
+    console.log(`  NOTE: only ${local.runs} run(s) on ${local.model} — too few to judge. Keep collecting.`);
+  } else if (local.opsPerRun === 0) {
+    console.log(`  WARNING: ${local.model} has emitted ZERO supersede/obsolete operations across ${local.runs} runs.`);
+    console.log(`  Beliefs are accumulating but never being revised — a filing cabinet, not a brain.`);
+  } else {
+    console.log(`  ${local.model}: ${local.opsPerRun} ops/run, ${local.supersededPerRun} superseded/run.`);
+  }
+}