peon-mem 1.0.7 → 1.0.8

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,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.7",
+  "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.`);
+  }
+}

package/dist/roundtable.d.ts

@@ -1,104 +0,0 @@
-import type { ProjectContext } from "./types.js";
-export type RoundtableAgent = "codex" | "claude";
-export type RoundtableAgentMode = "chat" | "research" | "implement" | "review" | "verify";
-export type RoundtableStage = "queued" | "discussion" | "proposals" | "critiques" | "synthesis" | "implementation" | "review" | "verification" | "complete" | "failed";
-export interface RoundtableTurn {
-    id: string;
-    agent: RoundtableAgent | "joint" | "user";
-    kind: "discussion" | "proposal" | "critique" | "recommendation" | "implementation" | "review" | "verification";
-    content: string;
-    createdAt: string;
-}
-export interface RoundtableActivity {
-    id: string;
-    agent: RoundtableAgent | "room";
-    type: "status" | "code" | "test" | "review" | "result" | "artifact";
-    title: string;
-    detail?: string;
-    state: "running" | "passed" | "failed" | "info";
-    createdAt: string;
-    updatedAt: string;
-}
-export interface RoundtableRun {
-    id: string;
-    projectPath: string;
-    question: string;
-    mode: "autonomous" | "focused";
-    status: "queued" | "running" | "open" | "awaiting_approval" | "executing" | "complete" | "rejected" | "failed";
-    stage: RoundtableStage;
-    createdAt: string;
-    updatedAt: string;
-    turns: RoundtableTurn[];
-    activities?: RoundtableActivity[];
-    liveSummary?: string;
-    synthesizedBy?: RoundtableAgent;
-    approvedAt?: string;
-    error?: string;
-}
-export interface RoundtableAgentRunner {
-    run(agent: RoundtableAgent, prompt: string, projectPath: string, mode?: RoundtableAgentMode): Promise<string>;
-    availability(): Promise<Record<RoundtableAgent, {
-        available: boolean;
-        label: string;
-    }>>;
-}
-export interface RoundtableMemoryPort {
-    getContext(input: {
-        projectPath: string;
-        query?: string;
-        maxChars?: number;
-    }): Promise<ProjectContext>;
-    saveProposal(projectPath: string, question: string, proposal: string): Promise<void>;
-    saveDecision(projectPath: string, question: string, decision: string): Promise<void>;
-    saveResult(projectPath: string, question: string, result: string): Promise<void>;
-}
-export interface RoundtableManagerOptions {
-    stateDir: string;
-    memory: RoundtableMemoryPort;
-    runner?: RoundtableAgentRunner;
-    now?: () => string;
-}
-export declare class RoundtableManager {
-    private readonly options;
-    private readonly runs;
-    private readonly subscribers;
-    private readonly runner;
-    private readonly now;
-    private queue;
-    private persistQueue;
-    constructor(options: RoundtableManagerOptions);
-    initialize(): Promise<void>;
-    availability(): Promise<Record<RoundtableAgent, {
-        available: boolean;
-        label: string;
-    }>>;
-    list(projectPath?: string): RoundtableRun[];
-    get(id: string): RoundtableRun | undefined;
-    subscribe(listener: (run: RoundtableRun) => void): () => void;
-    start(projectPath: string, rawQuestion?: string): Promise<RoundtableRun>;
-    approve(id: string): Promise<RoundtableRun>;
-    message(id: string, rawMessage: unknown): Promise<RoundtableRun>;
-    propose(id: string): Promise<RoundtableRun>;
-    continueDiscussion(id: string): Promise<RoundtableRun>;
-    reject(id: string): Promise<RoundtableRun>;
-    private execute;
-    private executeApproved;
-    private startActivity;
-    private addActivity;
-    private finishActivity;
-    private failRunningActivities;
-    private concludeAgreement;
-    private executeRevision;
-    private executeCasualReply;
-    private executeProposal;
-    private touch;
-    private emit;
-    private persist;
-}
-export declare class LocalSubscriptionRunner implements RoundtableAgentRunner {
-    availability(): Promise<Record<RoundtableAgent, {
-        available: boolean;
-        label: string;
-    }>>;
-    run(agent: RoundtableAgent, prompt: string, projectPath: string, mode?: RoundtableAgentMode): Promise<string>;
-}