peon-mem 1.0.7 → 1.0.9

package/dist/processor.js

@@ -1,5 +1,5 @@
 import { PeonMemoryStore } from "./memory-store.js";
-import { loadPeonConfig } from "./config.js";
+import { llmEnabled, loadPeonConfig } from "./config.js";
 import { createQualityReport } from "./quality.js";
 import { extractDomainEntitiesViaModel } from "./entity-extraction.js";
 export class PeonMemoryProcessor {
@@ -99,7 +99,9 @@ export class PeonMemoryProcessor {
             trigger: input.trigger,
             force: input.force ?? false,
             aiMode: this.config.aiMode,
-            hasApiKey: Boolean(this.config.openRouterApiKey),
+            // A local provider (Ollama) needs no key. Gating on openRouterApiKey here meant a
+            // fully-local setup skipped every automatic consolidation as "missing_api_key".
+            hasApiKey: llmEnabled(this.config),
             hasManualAiResult: Boolean(input.aiResult)
         });
         if (decision.action === "skip") {
@@ -202,6 +204,11 @@ export class OpenRouterMemoryModelClient {
                 // Reserve explicit output room. Without this, OpenRouter applies the provider's default
                 // completion cap, which — paired with the delta cap on the input side — keeps the JSON
                 // reply from truncating mid-object. Env-tunable for very large brains.
+                // Force a JSON-object reply. A hosted model usually obeys "reply with JSON" from
+                // the prompt alone; a local 7B often answers conversationally instead ("It sounds
+                // like..."), which fails the parse and loses the whole consolidation. Ollama and
+                // the OpenAI API both honour this flag, so ask for it rather than trusting prose.
+                response_format: { type: "json_object" },
                 max_tokens: Number(process.env.PEON_CONSOLIDATION_MAX_TOKENS) || 8192
             })
         });
@@ -210,6 +217,19 @@ export class OpenRouterMemoryModelClient {
             throw new Error(`OpenRouter memory processing failed with ${response.status}${body ? `: ${body}` : ""}`);
         }
         const json = (await response.json());
+        // A server whose context window is smaller than this prompt does not error: it
+        // keeps only the TAIL and silently drops the rest — which is the system prompt and
+        // the JSON schema. The model then answers without its instructions, and the result
+        // is empty or wrong. Refuse it rather than mark the session as consolidated.
+        const estimatedPromptTokens = estimatePromptTokensForTruncation(systemPrompt) + estimatePromptTokensForTruncation(userPrompt);
+        const reportedPromptTokens = json.usage?.prompt_tokens;
+        if (detectPromptTruncation(estimatedPromptTokens, reportedPromptTokens)) {
+            throw new Error(`The model server truncated the consolidation prompt: it processed ${reportedPromptTokens} tokens ` +
+                `of roughly ${estimatedPromptTokens} sent. Its context window is too small, so the instructions and ` +
+                `schema were cut off and the result would be empty. The session log was NOT consumed and will be ` +
+                `retried. Fix: give the model a larger context window — for Ollama, create a model with ` +
+                `"PARAMETER num_ctx 32768" (or set OLLAMA_CONTEXT_LENGTH) and point PEON_PROCESSING_MODEL at it.`);
+        }
         const content = json.choices?.[0]?.message?.content;
         if (!content)
             throw new Error("OpenRouter memory processing response did not include content.");
@@ -351,6 +371,69 @@ function isMemoryStatus(value) {
 function estimateTokens(text) {
     return Math.max(1, Math.ceil(text.length / 4));
 }
+/**
+ * Did the model server silently truncate the prompt?
+ *
+ * OpenAI-compatible servers report usage.prompt_tokens: what the model actually read.
+ * Ollama, at its 4096-token default, reports exactly 4096 for a ~17K-token prompt.
+ *
+ * The estimate comes from estimatePromptTokensForTruncation, and the threshold has to
+ * respect how rough it is. For English that estimate is chars/4, which OVER-estimates
+ * (real text runs ~5.5 chars/token), so an untruncated prompt still reports ~0.73 of
+ * it. A truncated one reports ~0.24. Below 0.5 is unambiguous: reaching it without
+ * truncation would take 8+ chars per token. Small prompts are ignored, where
+ * estimation noise is a large share of the total.
+ */
+export function detectPromptTruncation(estimatedPromptTokens, reportedPromptTokens) {
+    if (!reportedPromptTokens || reportedPromptTokens <= 0)
+        return false; // no usage reported: cannot tell
+    if (estimatedPromptTokens - reportedPromptTokens < 1000)
+        return false;
+    return reportedPromptTokens / estimatedPromptTokens < 0.5;
+}
+/** Scripts that tokenize at roughly one token per character or more, not one per word. */
+const TOKEN_DENSE_SCRIPT = /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}\p{Script=Bopomofo}\u3000-\u303F\uFF00-\uFFEF]/u;
+const TOKENS_PER_ASCII_CHAR = 1 / 4;
+const TOKENS_PER_DENSE_CHAR = 0.75;
+const TOKENS_PER_OTHER_CHAR = 0.35;
+/**
+ * Prompt size estimate for detectPromptTruncation ONLY. estimateTokens (chars/4) stays
+ * the cost/reporting estimate; this one exists because chars/4 undercounts token-dense
+ * scripts, which let a truncated CJK prompt pass as untruncated.
+ *
+ * The detector flags reported/estimated < 0.5, so each weight has to sit between two
+ * limits: high enough that a truncated prompt falls below 0.5, and at most ~2x the
+ * MOST efficient tokenizer's rate, or an untruncated prompt falls below 0.5 too. That
+ * false positive is the worse failure: the session is refused on every retry.
+ *
+ * - ASCII, 1/4 per char: unchanged, so English behaves exactly as before (chars/4
+ *   over-counts English ~1.4x; measured untruncated ratio 0.73, truncated 0.24).
+ * - Han, kana, hangul, bopomofo, CJK and fullwidth punctuation, 0.75 per char: efficient
+ *   tokenizers run ~0.45-0.6 tokens per CJK char, giving an untruncated ratio of 0.6-0.8.
+ *   Qwen2.5 on Ollama runs ~0.65, so a truncated CJK prompt now reads well under 0.5.
+ * - Any other non-ASCII, 0.35 per char: Cyrillic, Greek, Arabic, accented Latin and the
+ *   like pack into ~0.22-0.35 tokens per char on large-vocabulary tokenizers. A flat 0.75
+ *   here would read an untruncated Russian log at ~0.31 and block it forever.
+ *
+ * Iterates code points, so an astral character (CJK Extension B, emoji) counts once.
+ */
+export function estimatePromptTokensForTruncation(text) {
+    // Count per class and multiply once: summing 0.35 thousands of times drifts past the
+    // integer and Math.ceil would round it up.
+    let ascii = 0;
+    let dense = 0;
+    let other = 0;
+    for (const char of text) {
+        if ((char.codePointAt(0) ?? 0) < 0x80)
+            ascii += 1;
+        else if (TOKEN_DENSE_SCRIPT.test(char))
+            dense += 1;
+        else
+            other += 1;
+    }
+    const tokens = ascii * TOKENS_PER_ASCII_CHAR + dense * TOKENS_PER_DENSE_CHAR + other * TOKENS_PER_OTHER_CHAR;
+    return Math.max(1, Math.ceil(tokens));
+}
 function estimateTokensByChars(chars) {
     return Math.max(0, Math.ceil(chars / 4));
 }

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,17 @@ 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;
+};
+/**
+ * PEON_DAEMON_URL as an http(s) base URL, or undefined to run the tools in-process.
+ *
+ * The variable is optional, and registry listings render it with a placeholder value
+ * ("your-peon-daemon-url-here"). A copied placeholder must not turn a working in-process
+ * server into one where every call fails, so anything that is not an http(s) URL is
+ * dropped with a warning on stderr (stdout carries the MCP protocol).
+ */
+export declare function resolveDaemonUrl(raw: string | undefined, warn?: (message: string) => void): string | undefined;
 export declare function createPeonTools(options?: CreatePeonToolsOptions): PeonTools;

package/dist/tools.js

@@ -14,19 +14,69 @@ 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 };
+}
+/**
+ * PEON_DAEMON_URL as an http(s) base URL, or undefined to run the tools in-process.
+ *
+ * The variable is optional, and registry listings render it with a placeholder value
+ * ("your-peon-daemon-url-here"). A copied placeholder must not turn a working in-process
+ * server into one where every call fails, so anything that is not an http(s) URL is
+ * dropped with a warning on stderr (stdout carries the MCP protocol).
+ */
+export function resolveDaemonUrl(raw, warn = (message) => console.warn(message)) {
+    const value = raw?.trim();
+    if (!value)
+        return undefined;
+    try {
+        const { protocol } = new URL(value);
+        if (protocol === "http:" || protocol === "https:")
+            return value;
+    }
+    catch {
+        // not a URL at all: fall through to the warning
+    }
+    warn(`[peon] ignoring PEON_DAEMON_URL=${JSON.stringify(value)}: not an http(s) URL. Running the tools in-process instead.`);
+    return undefined;
+}
 export function createPeonTools(options = {}) {
-    if (options.daemonUrl) {
-        return createDaemonBackedTools(options.daemonUrl);
+    const daemonUrl = resolveDaemonUrl(options.daemonUrl);
+    if (daemonUrl) {
+        return createDaemonBackedTools(daemonUrl);
     }
     const storesByProject = new Map();
     const sessionIndex = new SessionIndex(options.sessionIndexPath);
     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) {
@@ -366,7 +416,7 @@ function createDaemonBackedTools(daemonUrl) {
                 url.searchParams.set("query", input.query);
             if (input.maxChars)
                 url.searchParams.set("maxChars", String(input.maxChars));
-            const response = await fetch(url);
+            const response = await daemonFetch(url);
             return readJsonResponse(response);
         },
         async inspectBrain(input) {
@@ -376,7 +426,7 @@ function createDaemonBackedTools(daemonUrl) {
                 url.searchParams.set("query", input.query);
             if (input.maxChars)
                 url.searchParams.set("maxChars", String(input.maxChars));
-            const response = await fetch(url);
+            const response = await daemonFetch(url);
             return readJsonResponse(response);
         },
         async searchMemory(input) {
@@ -387,7 +437,7 @@ function createDaemonBackedTools(daemonUrl) {
                 url.searchParams.set("limit", String(input.limit));
             if (input.maxChars)
                 url.searchParams.set("maxChars", String(input.maxChars));
-            const response = await fetch(url);
+            const response = await daemonFetch(url);
             return readJsonResponse(response);
         },
         async qualityReport(input) {
@@ -395,7 +445,7 @@ function createDaemonBackedTools(daemonUrl) {
             url.searchParams.set("projectPath", input.projectPath);
             if (input.staleAfterDays)
                 url.searchParams.set("staleAfterDays", String(input.staleAfterDays));
-            const response = await fetch(url);
+            const response = await daemonFetch(url);
             return readJsonResponse(response);
         },
         async rememberGlobal(input) {
@@ -409,7 +459,7 @@ function createDaemonBackedTools(daemonUrl) {
                 url.searchParams.set("type", input.type);
             if (input.status)
                 url.searchParams.set("status", input.status);
-            const response = await fetch(url);
+            const response = await daemonFetch(url);
             return readJsonResponse(response);
         },
         async importGlobalMemory(input) {
@@ -434,17 +484,17 @@ function createDaemonBackedTools(daemonUrl) {
             const url = new URL(`${baseUrl}/brain/activity`);
             if (input.limit)
                 url.searchParams.set("limit", String(input.limit));
-            return readJsonResponse(await fetch(url));
+            return readJsonResponse(await daemonFetch(url));
         },
         async globalDashboard() {
-            return readJsonResponse(await fetch(`${baseUrl}/global/dashboard`));
+            return readJsonResponse(await daemonFetch(`${baseUrl}/global/dashboard`));
         },
         async brainActions(input) {
             const url = new URL(`${baseUrl}/brain/actions`);
             url.searchParams.set("projectPath", input.projectPath);
             if (input.limit)
                 url.searchParams.set("limit", String(input.limit));
-            return readJsonResponse(await fetch(url));
+            return readJsonResponse(await daemonFetch(url));
         },
         async restoreBackup(input) {
             return postJson(`${baseUrl}/brain/restore`, input);
@@ -470,7 +520,7 @@ function createDaemonBackedTools(daemonUrl) {
                 url.searchParams.set("maxChars", String(input.maxChars));
             if (input.includeInactive)
                 url.searchParams.set("includeInactive", "true");
-            const response = await fetch(url);
+            const response = await daemonFetch(url);
             return readJsonResponse(response);
         },
         async crossProjectSearch(input) {
@@ -486,7 +536,7 @@ function createDaemonBackedTools(daemonUrl) {
                 url.searchParams.set("limit", String(input.limit));
             if (input.maxProjects)
                 url.searchParams.set("maxProjects", String(input.maxProjects));
-            const response = await fetch(url);
+            const response = await daemonFetch(url);
             return readJsonResponse(response);
         },
         async processMemory(input) {
@@ -528,13 +578,25 @@ function formatSearchInjectionPreview(records) {
     return ["Peon Search Results", ...records.map(formatRankedMemoryRecord)].join("\n");
 }
 async function postJson(url, body) {
-    const response = await fetch(url, {
+    const response = await daemonFetch(url, {
         method: "POST",
         headers: { "content-type": "application/json" },
         body: JSON.stringify(body)
     });
     return readJsonResponse(response);
 }
+/** fetch against the daemon, with an actionable error when nothing answers there. */
+async function daemonFetch(url, init) {
+    try {
+        return await fetch(url, init);
+    }
+    catch (error) {
+        const reason = error.cause?.code ?? (error instanceof Error ? error.message : String(error));
+        throw new Error(`Peon daemon is not reachable at ${new URL(String(url)).origin} (${reason}). Start it with ` +
+            `"npx peon-mem install" (sets it up as a background service) or "npx peon-mem daemon", ` +
+            `or unset PEON_DAEMON_URL to run the tools in-process.`);
+    }
+}
 async function readJsonResponse(response) {
     const text = await response.text();
     const body = text ? JSON.parse(text) : {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "peon-mem",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "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": [