peon-mem 1.0.7 → 1.0.8

package/dist/compression.js

@@ -1,3 +1,4 @@
+import { llmEnabled, llmEndpoint, llmHeaders } from "./config.js";
 /**
  * Builds the LLM summarizer the brain uses to compress a topic cluster into one
  * gist belief. Kept separate from brain.ts so the curation logic stays pure and
@@ -5,7 +6,7 @@
  * or no key is configured (the brain then runs cost-free, skipping compression).
  */
 export function createClusterSummarizer(config) {
-    if (config.aiMode === "off" || !config.openRouterApiKey)
+    if (!llmEnabled(config))
         return null;
     return async (cluster) => {
         const beliefs = cluster.members.map((m, i) => `${i + 1}. ${m.content}`).join("\n");
@@ -14,9 +15,9 @@ export function createClusterSummarizer(config) {
             "Losing a specific fact is a failure; merge wording, never drop information. Drop only redundancy and filler. " +
             "Output ONLY the summary sentence(s) — no preamble, no markdown, no quotes around it. Max 240 characters.";
         const user = `Topic: ${cluster.entity}\n\nBeliefs to compress:\n${beliefs}\n\nOne compact summary:`;
-        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/config.d.ts

@@ -19,4 +19,17 @@ export interface PeonConfig {
 type Env = Record<string, string | undefined>;
 export declare function loadPeonConfig(env?: Env): PeonConfig;
 export declare function readEnvFile(startDir?: string): Env;
+/**
+ * Is an LLM available for optional AI passes (compression, entity extraction, HyDE,
+ * global extraction)?
+ *
+ * These used to gate on `openRouterApiKey`, which meant a fully-local setup
+ * (PEON_PROVIDER=ollama, no OpenRouter key) silently skipped every one of them —
+ * "local mode" was not actually local. A local provider needs no key; a hosted one does.
+ */
+export declare function llmEnabled(config: PeonConfig): boolean;
+/** The chat-completions endpoint for the configured provider. */
+export declare function llmEndpoint(config: PeonConfig): string;
+/** Auth + content headers for the configured provider (local providers need no key). */
+export declare function llmHeaders(config: PeonConfig): Record<string, string>;
 export {};

package/dist/config.js

@@ -97,3 +97,29 @@ function findEnvFile(startDir) {
         current = dirname(current);
     }
 }
+/**
+ * Is an LLM available for optional AI passes (compression, entity extraction, HyDE,
+ * global extraction)?
+ *
+ * These used to gate on `openRouterApiKey`, which meant a fully-local setup
+ * (PEON_PROVIDER=ollama, no OpenRouter key) silently skipped every one of them —
+ * "local mode" was not actually local. A local provider needs no key; a hosted one does.
+ */
+export function llmEnabled(config) {
+    if (config.aiMode === "off")
+        return false;
+    if (config.provider === "ollama")
+        return true;
+    return Boolean(config.llmApiKey ?? config.openRouterApiKey);
+}
+/** The chat-completions endpoint for the configured provider. */
+export function llmEndpoint(config) {
+    return `${config.llmBaseUrl.replace(/\/$/, "")}/chat/completions`;
+}
+/** Auth + content headers for the configured provider (local providers need no key). */
+export function llmHeaders(config) {
+    return {
+        Authorization: `Bearer ${config.llmApiKey ?? config.openRouterApiKey ?? ""}`,
+        "Content-Type": "application/json"
+    };
+}

package/dist/daemon.d.ts

@@ -1,11 +1,8 @@
-import { type RoundtableAgentRunner } from "./roundtable.js";
 export interface StartPeonDaemonOptions {
     host?: string;
     port?: number;
     logDir?: string;
     globalMemoryDir?: string;
-    /** Override the local Codex/Claude bridge. Intended for tests and custom launchers. */
-    roundtableRunner?: RoundtableAgentRunner;
 }
 export interface PeonDaemonHandle {
     host: string;

package/dist/daemon.js

@@ -7,7 +7,6 @@ import { URL } from "node:url";
 import { PeonLogger } from "./logger.js";
 import { renderMonitorHtml } from "./monitor.js";
 import { renderTokenAbMonitorHtml } from "./token-ab-monitor.js";
-import { RoundtableManager } from "./roundtable.js";
 import { SessionIndex } from "./session-index.js";
 import { createPeonTools } from "./tools.js";
 import { summarizeBeliefs, detectDuplicates, computeTokenSavings, enrichInjection, filterStrayProjects } from "./overview.js";
@@ -103,9 +102,9 @@ export function canonicalProjectPath(projectPath, home = homedir()) {
 /**
  * Reject requests that aren't from a loopback caller — defeats DNS-rebinding and drive-by-localhost
  * attacks where a malicious web page POSTs to the daemon (which would otherwise write/read a brain
- * at an attacker-controlled path). A bad Host header (rebinding) or a cross-origin Origin/Referer
- * (browser drive-by) is refused. The node hook (no Origin) and the local monitor UI (loopback
- * Origin) both pass.
+ * at an attacker-controlled path). A bad Host header (rebinding), a cross-origin Origin/Referer
+ * (browser drive-by) or a browser's Sec-Fetch-Site: cross-site is refused. The node hook (no
+ * Origin) and the local monitor UI (loopback Origin, same-origin fetches) all pass.
  */
 function isLoopbackHostname(hostname) {
     const h = hostname.toLowerCase().replace(/^\[|\]$/g, "");
@@ -129,6 +128,12 @@ function isLocalRequest(request) {
     // A present Host must be loopback (a missing Host — rare, HTTP/1.0 — is allowed; bind is 127.0.0.1).
     if (rawHost !== undefined && !isLoopbackHostname(hostnameFromHostHeader(String(rawHost))))
         return false;
+    // Browsers label every request with where it came from. An <img> or no-referrer fetch from
+    // another site carries no Origin or Referer, so the loop below cannot see it, yet a GET like
+    // /context?projectPath=... still creates a brain at that path. Non-browser callers (the hook,
+    // the MCP server, curl) send no Sec-Fetch-Site and are unaffected.
+    if (String(request.headers["sec-fetch-site"] ?? "").toLowerCase() === "cross-site")
+        return false;
     for (const header of [request.headers.origin, request.headers.referer]) {
         if (!header)
             continue;
@@ -159,53 +164,6 @@ export async function startPeonDaemon(options = {}) {
     const tools = createPeonTools({ globalMemoryDir: options.globalMemoryDir, sessionIndexPath });
     const logger = new PeonLogger({ logDir: options.logDir });
     const projectRegistry = new ProjectRegistry(stateDir);
-    const roundtable = new RoundtableManager({
-        stateDir: join(stateDir, "roundtables"),
-        runner: options.roundtableRunner,
-        memory: {
-            getContext: (input) => tools.getContext(input),
-            saveProposal: async (projectPath, question, proposal) => {
-                const session = await tools.startSession({ projectPath, client: "peon-roundtable", cwd: projectPath });
-                try {
-                    await tools.recordEvent({
-                        sessionId: session.sessionId,
-                        type: "roundtable_proposal",
-                        content: `Roundtable proposal for “${question.slice(0, 220)}”: ${proposal.slice(0, 6_000)}`
-                    });
-                }
-                finally {
-                    await tools.endSession({ sessionId: session.sessionId }).catch(() => undefined);
-                }
-            },
-            saveDecision: async (projectPath, question, decision) => {
-                const session = await tools.startSession({ projectPath, client: "peon-roundtable", cwd: projectPath });
-                try {
-                    await tools.recordEvent({
-                        sessionId: session.sessionId,
-                        type: "decision",
-                        content: `Roundtable decision for “${question.slice(0, 220)}”: ${decision.slice(0, 6_000)}`
-                    });
-                }
-                finally {
-                    await tools.endSession({ sessionId: session.sessionId }).catch(() => undefined);
-                }
-            },
-            saveResult: async (projectPath, question, result) => {
-                const session = await tools.startSession({ projectPath, client: "peon-roundtable", cwd: projectPath });
-                try {
-                    await tools.recordEvent({
-                        sessionId: session.sessionId,
-                        type: "roundtable_result",
-                        content: `Roundtable implementation result for “${question.slice(0, 220)}”: ${result.slice(0, 6_000)}`
-                    });
-                }
-                finally {
-                    await tools.endSession({ sessionId: session.sessionId }).catch(() => undefined);
-                }
-            }
-        }
-    });
-    await roundtable.initialize();
     const sessionIndex = new SessionIndex(sessionIndexPath);
     const activeSessions = new Map();
     // Clear zombie sessions left behind by a crashed run before rehydrating, so the
@@ -251,8 +209,7 @@ export async function startPeonDaemon(options = {}) {
             sendJson(response, 403, { error: "forbidden: non-local request origin" });
             return;
         }
-        const noisy = NOISY_LOG_PATHS.has(requestUrl.pathname) ||
-            (requestMethod === "GET" && requestUrl.pathname.startsWith("/roundtable/"));
+        const noisy = NOISY_LOG_PATHS.has(requestUrl.pathname);
         if (!noisy) {
             await logger.log("request_in", {
                 requestId,
@@ -262,36 +219,7 @@ export async function startPeonDaemon(options = {}) {
             });
         }
         try {
-            if (requestMethod === "GET" && requestUrl.pathname === "/roundtable/events") {
-                const rawProjectPath = requestUrl.searchParams.get("projectPath");
-                if (!rawProjectPath)
-                    throw new BadRequestError("projectPath is required");
-                const projectPath = canonicalProjectPath(rawProjectPath);
-                response.writeHead(200, {
-                    "content-type": "text/event-stream; charset=utf-8",
-                    "cache-control": "no-cache, no-transform",
-                    connection: "keep-alive",
-                    "x-accel-buffering": "no"
-                });
-                response.write(": thesis room connected\n\n");
-                const unsubscribe = roundtable.subscribe((run) => {
-                    if (run.projectPath !== projectPath || response.writableEnded)
-                        return;
-                    response.write(`data: ${JSON.stringify(run)}\n\n`);
-                });
-                const heartbeat = setInterval(() => {
-                    if (!response.writableEnded)
-                        response.write(": keep-alive\n\n");
-                }, 20_000);
-                if (typeof heartbeat.unref === "function")
-                    heartbeat.unref();
-                request.on("close", () => {
-                    clearInterval(heartbeat);
-                    unsubscribe();
-                });
-                return;
-            }
-            const result = await routeRequest(request, tools, activeSessions, monitorState, logger, projectRegistry, roundtable);
+            const result = await routeRequest(request, tools, activeSessions, monitorState, logger, projectRegistry);
             if ("html" in result) {
                 sendHtml(response, result.status ?? 200, result.html);
             }
@@ -422,15 +350,12 @@ async function maybeRecurate(tools, monitorState, logger) {
         await logger.log("recurate_fail", { projectPath, error: error instanceof Error ? error.message : "unknown" });
     }
 }
-async function routeRequest(request, tools, activeSessions, monitorState, logger, projectRegistry, roundtable) {
+async function routeRequest(request, tools, activeSessions, monitorState, logger, projectRegistry) {
     const url = new URL(request.url ?? "/", "http://127.0.0.1");
     const method = request.method ?? "GET";
     if (method === "GET" && url.pathname === "/health") {
         return { body: { ok: true, service: "peon-daemon" } };
     }
-    if (method === "GET" && url.pathname === "/favicon.ico") {
-        return { status: 204, body: "" };
-    }
     if ((method === "GET" || method === "HEAD") && url.pathname === "/monitor") {
         return { html: renderMonitorHtml() };
     }
@@ -440,56 +365,6 @@ async function routeRequest(request, tools, activeSessions, monitorState, logger
     if (method === "GET" && url.pathname === "/monitor/state") {
         return { body: await buildMonitorState(tools, activeSessions, monitorState, logger) };
     }
-    if (method === "GET" && url.pathname === "/roundtable/status") {
-        return { body: { agents: await roundtable.availability() } };
-    }
-    if (method === "GET" && url.pathname === "/roundtable/runs") {
-        const rawProjectPath = url.searchParams.get("projectPath");
-        const projectPath = rawProjectPath ? canonicalProjectPath(rawProjectPath) : undefined;
-        return { body: { runs: roundtable.list(projectPath).slice(0, 30) } };
-    }
-    const roundtableRunMatch = url.pathname.match(/^\/roundtable\/runs\/([^/]+)$/);
-    if (method === "GET" && roundtableRunMatch) {
-        const run = roundtable.get(decodeURIComponent(roundtableRunMatch[1]));
-        if (!run)
-            return { status: 404, body: { error: "Roundtable discussion not found" } };
-        return { body: run };
-    }
-    if (method === "POST" && url.pathname === "/roundtable/runs") {
-        const input = await readJson(request);
-        if (!input.projectPath)
-            throw new BadRequestError("projectPath is required");
-        const projectPath = canonicalProjectPath(input.projectPath);
-        if (!monitorState.knownProjects.has(projectPath) && !isRealProjectPath(projectPath)) {
-            throw new BadRequestError("Select a project already known to Peon");
-        }
-        const availability = await roundtable.availability();
-        const missing = ["codex", "claude"].filter((agent) => !availability[agent].available);
-        if (missing.length)
-            throw new BadRequestError(`Local client unavailable: ${missing.join(" and ")}`);
-        await rememberProject(monitorState, projectRegistry, projectPath);
-        return { status: 202, body: await roundtable.start(projectPath, input.question) };
-    }
-    const roundtableApprovalMatch = url.pathname.match(/^\/roundtable\/runs\/([^/]+)\/(approve|reject)$/);
-    if (method === "POST" && roundtableApprovalMatch) {
-        const id = decodeURIComponent(roundtableApprovalMatch[1]);
-        const action = roundtableApprovalMatch[2];
-        return { body: action === "approve" ? await roundtable.approve(id) : await roundtable.reject(id) };
-    }
-    const roundtableProposalMatch = url.pathname.match(/^\/roundtable\/runs\/([^/]+)\/propose$/);
-    if (method === "POST" && roundtableProposalMatch) {
-        return { body: await roundtable.propose(decodeURIComponent(roundtableProposalMatch[1])) };
-    }
-    const roundtableContinueMatch = url.pathname.match(/^\/roundtable\/runs\/([^/]+)\/continue$/);
-    if (method === "POST" && roundtableContinueMatch) {
-        return { body: await roundtable.continueDiscussion(decodeURIComponent(roundtableContinueMatch[1])) };
-    }
-    const roundtableMessageMatch = url.pathname.match(/^\/roundtable\/runs\/([^/]+)\/message$/);
-    if (method === "POST" && roundtableMessageMatch) {
-        const id = decodeURIComponent(roundtableMessageMatch[1]);
-        const input = await readJson(request);
-        return { body: await roundtable.message(id, input.message) };
-    }
     if (method === "GET" && url.pathname === "/logs") {
         const limit = Number.parseInt(url.searchParams.get("limit") ?? "100", 10);
         return { body: { entries: await logger.recent(Number.isFinite(limit) ? limit : 100) } };

package/dist/embedding-store.d.ts

@@ -20,6 +20,14 @@ export interface SyncResult {
     reused: number;
     pruned: number;
 }
+export declare function embeddingCacheStats(): {
+    cachedStores: number;
+    diskReads: number;
+    reads: number;
+    expireOlderThan: (now: number) => void;
+};
+/** Test helper: forget every cached sidecar. */
+export declare function resetEmbeddingCaches(): void;
 /** Test helper: forget learned widths, simulating a fresh daemon process. */
 export declare function resetEmbeddingDimensionCache(): void;
 export declare class EmbeddingStore {
@@ -35,6 +43,8 @@ export declare class EmbeddingStore {
      * empty map rather than throwing (retrieval falls back to lexical-only).
      */
     sync(records: MemoryRecord[], client: EmbeddingClient | null): Promise<SyncResult>;
+    /** Release this store's parsed sidecar. Costs one re-read, never correctness. */
+    dropCache(): void;
     /** Read vectors without recomputing — used by read-only retrieval paths. */
     vectorById(): Promise<Map<string, EmbeddingVector>>;
     private persist;

package/dist/embedding-store.js

@@ -1,6 +1,67 @@
 import { mkdir, readFile, rename, stat, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { contentHash } from "./embeddings.js";
+/**
+ * Bounded registry of live sidecar caches.
+ *
+ * The cache below keeps a whole embeddings.jsonl parsed in memory so read-only
+ * retrieval doesn't re-parse a multi-MB file on every prompt. That is a real win,
+ * but the daemon holds one store per project and nothing evicted: a heap snapshot
+ * showed 8 stores pinning 60,288 Float32Array vectors / 338 MB of native backing,
+ * with RSS past 1.9 GB — enough GC pressure to peg the CPU and stop the daemon
+ * answering. So caches are now LRU-bounded and released once idle; a dropped cache
+ * costs one re-read, never correctness.
+ */
+const MAX_CACHED_STORES = Number(process.env.PEON_EMBED_CACHE_STORES) > 0
+    ? Number(process.env.PEON_EMBED_CACHE_STORES)
+    : 2;
+const CACHE_TTL_MS = Number(process.env.PEON_EMBED_CACHE_TTL_MS) > 0
+    ? Number(process.env.PEON_EMBED_CACHE_TTL_MS)
+    : 5 * 60 * 1000;
+/** Insertion order is LRU order: least-recently-used first. */
+const liveCaches = new Map();
+let diskReads = 0;
+function touchCache(store, at) {
+    liveCaches.delete(store);
+    liveCaches.set(store, at);
+    pruneCaches(at);
+}
+function pruneCaches(now) {
+    for (const [store, touchedAt] of [...liveCaches]) {
+        if (now - touchedAt > CACHE_TTL_MS) {
+            store.dropCache();
+            liveCaches.delete(store);
+        }
+    }
+    while (liveCaches.size > MAX_CACHED_STORES) {
+        const oldest = liveCaches.keys().next().value;
+        if (!oldest)
+            break;
+        oldest.dropCache();
+        liveCaches.delete(oldest);
+    }
+}
+// TTL alone only fires on activity, so an idle daemon would hold its last caches
+// forever. A low-frequency sweeper lets a quiet daemon settle back down; unref'd
+// so it never keeps the process alive on its own.
+const sweeper = setInterval(() => pruneCaches(Date.now()), 60_000);
+if (typeof sweeper.unref === "function")
+    sweeper.unref();
+export function embeddingCacheStats() {
+    return {
+        cachedStores: liveCaches.size,
+        diskReads,
+        reads: diskReads,
+        expireOlderThan: (now) => pruneCaches(now)
+    };
+}
+/** Test helper: forget every cached sidecar. */
+export function resetEmbeddingCaches() {
+    for (const store of [...liveCaches.keys()])
+        store.dropCache();
+    liveCaches.clear();
+    diskReads = 0;
+}
 /** Real output width per embedding model, learned once per process. */
 const modelDimensions = new Map();
 /** Test helper: forget learned widths, simulating a fresh daemon process. */
@@ -29,8 +90,11 @@ export class EmbeddingStore {
         catch {
             mtimeMs = 0; // missing file → treat as empty, mtime 0
         }
-        if (this.cache && this.cache.mtimeMs === mtimeMs)
+        if (this.cache && this.cache.mtimeMs === mtimeMs) {
+            touchCache(this, Date.now());
             return this.cache.map;
+        }
+        diskReads += 1;
         const raw = await readFile(this.filePath, "utf8").catch(() => "");
         const map = new Map();
         for (const line of raw.split(/\r?\n/)) {
@@ -47,6 +111,7 @@ export class EmbeddingStore {
             }
         }
         this.cache = { mtimeMs, map };
+        touchCache(this, Date.now());
         return map;
     }
     /**
@@ -63,19 +128,19 @@ export class EmbeddingStore {
         const liveIds = new Set(records.map((record) => record.id));
         const pruned = [...existing.keys()].filter((id) => !liveIds.has(id)).length;
         // A stored vector can carry the right model name and hash yet the wrong width —
-        // that is what a degraded fallback wrote — and cosineSimilarity returns 0 on a
-        // length mismatch, so those records vanish from semantic recall without erroring.
-        // Width is part of validity. Learning it must not cost a round trip per sync, so
-        // it is cached per model and only probed when nothing else needs recomputing:
-        // precisely the case where a fully-poisoned sidecar looks entirely reusable.
-        const matchesStored = (record) => {
-            const prior = existing.get(record.id);
-            return prior && prior.model === client.model && prior.hash === contentHash(embeddingText(record))
-                ? prior
-                : undefined;
-        };
+        // that is exactly what a degraded fallback wrote — and cosineSimilarity scores any
+        // width mismatch as 0, so those records vanish from semantic recall without ever
+        // erroring. Width is part of validity, so we need to know the client's real width.
+        //
+        // Learning it must not cost a round trip on every sync: the width is cached per
+        // model for the process, and only probed when there is nothing to compute (the
+        // one case where a fully-poisoned sidecar would otherwise look entirely reusable).
         let expectedDim = modelDimensions.get(client.model) ?? 0;
-        if (expectedDim === 0 && records.length > 0 && records.every((record) => matchesStored(record))) {
+        const nothingToRecompute = records.every((record) => {
+            const prior = existing.get(record.id);
+            return prior && prior.model === client.model && prior.hash === contentHash(embeddingText(record));
+        });
+        if (expectedDim === 0 && records.length > 0 && nothingToRecompute) {
             try {
                 const probe = await client.embed([embeddingText(records[0])]);
                 if (!client.degraded && probe[0]?.length) {
@@ -87,11 +152,15 @@ export class EmbeddingStore {
                 expectedDim = 0; // cannot probe — fall back to model+hash validity only
             }
         }
-        const valid = (prior) => Boolean(prior) && (expectedDim === 0 || prior.vector.length === expectedDim);
+        const validDim = (vector) => expectedDim === 0 || vector.length === expectedDim;
         const toCompute = [];
         let reused = 0;
         for (const record of records) {
-            if (valid(matchesStored(record))) {
+            const prior = existing.get(record.id);
+            if (prior &&
+                prior.model === client.model &&
+                prior.hash === contentHash(embeddingText(record)) &&
+                validDim(prior.vector)) {
                 reused += 1;
             }
             else {
@@ -100,17 +169,21 @@ export class EmbeddingStore {
         }
         const result = new Map();
         for (const record of records) {
-            const prior = matchesStored(record);
-            if (valid(prior))
+            const prior = existing.get(record.id);
+            if (prior &&
+                prior.model === client.model &&
+                prior.hash === contentHash(embeddingText(record)) &&
+                validDim(prior.vector)) {
                 result.set(record.id, prior);
+            }
         }
         let computed = 0;
         if (toCompute.length > 0) {
             try {
                 const vectors = await client.embed(toCompute.map((record) => embeddingText(record)));
                 // A degraded run returns local trigram vectors. Serving them for THIS call is
-                // graceful degradation; writing them under the primary model's name is not —
-                // they would be reused forever as if they were real embeddings.
+                // fine (graceful degradation); writing them under the primary's model name is
+                // not — they would be reused forever as if they were real embeddings.
                 if (client.degraded) {
                     const degradedById = new Map();
                     for (const [id, stored] of result)
@@ -148,6 +221,10 @@ export class EmbeddingStore {
             vectorById.set(id, stored.vector);
         return { vectorById, computed, reused, pruned };
     }
+    /** Release this store's parsed sidecar. Costs one re-read, never correctness. */
+    dropCache() {
+        this.cache = undefined;
+    }
     /** Read vectors without recomputing — used by read-only retrieval paths. */
     async vectorById() {
         const stored = await this.load();
@@ -170,6 +247,7 @@ export class EmbeddingStore {
         await writeFile(tmp, lines.length > 0 ? `${lines.join("\n")}\n` : "", "utf8");
         await rename(tmp, this.filePath);
         this.cache = undefined; // invalidate; next load() re-reads the fresh file
+        liveCaches.delete(this);
     }
 }
 /** Embed the record type alongside content so type acts as a soft semantic anchor. */

package/dist/entity-extraction.js

@@ -1,9 +1,10 @@
+import { llmEnabled, llmEndpoint, llmHeaders } from "./config.js";
 const DEFAULT_MAX_ITEMS = 40;
 const DEFAULT_SNIPPET_CHARS = 240;
 export async function extractDomainEntitiesViaModel(items, options) {
     const out = new Map();
     const { config } = options;
-    if (items.length === 0 || config.aiMode === "off" || !config.openRouterApiKey)
+    if (items.length === 0 || !llmEnabled(config))
         return out;
     const doFetch = options.fetchImpl ?? globalThis.fetch;
     if (!doFetch)
@@ -19,9 +20,9 @@ export async function extractDomainEntitiesViaModel(items, options) {
         '{"n": <snippet number>, "entities": ["..."]}, empty array when a snippet names none. No prose, no fences.';
     const user = `Snippets:\n${numbered}\n\nJSON array:`;
     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}`, "Content-Type": "application/json" },
+            headers: llmHeaders(config),
             body: JSON.stringify({
                 model: options.model ?? config.processingModel,
                 messages: [

package/dist/global-extraction.js

@@ -1,5 +1,6 @@
+import { llmEnabled, llmEndpoint, llmHeaders } from "./config.js";
 export function createGlobalExtractor(config) {
-    if (config.aiMode === "off" || !config.openRouterApiKey)
+    if (!llmEnabled(config))
         return null;
     return async (records) => {
         // Send the highest-signal beliefs only — bounds tokens, focuses the model.
@@ -22,9 +23,9 @@ export function createGlobalExtractor(config) {
             "Example DROP (project-internal): 'The daemon exposes a /global/extract endpoint.' " +
             "Rewrite each as one self-contained sentence with zero project context. " +
             "Output ONLY a JSON array of strings — no markdown fences, no prose. If nothing qualifies, return []. Max 8 items.";
-        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/hyde.js

@@ -1,10 +1,11 @@
+import { llmEnabled, llmEndpoint } from "./config.js";
 const DEFAULT_MAX_CHARS = 320;
 export async function expandQuery(query, options) {
     const q = (query ?? "").trim();
     if (!q)
         return { expanded: "", hypothetical: "" };
     const { config } = options;
-    if (config.aiMode === "off" || !config.openRouterApiKey)
+    if (!llmEnabled(config))
         return { expanded: q, hypothetical: "" };
     const doFetch = options.fetchImpl ?? globalThis.fetch;
     if (!doFetch)
@@ -16,10 +17,10 @@ export async function expandQuery(query, options) {
         "Do not hedge, do not say you lack context, do not ask questions. Output the sentences only.";
     const user = `Question: ${q}\n\nHypothetical answer:`;
     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/logger.d.ts

@@ -1,5 +1,9 @@
 export interface PeonLoggerOptions {
     logDir?: string;
+    /** Rotate the live log once it exceeds this many bytes. */
+    maxBytes?: number;
+    /** Upper bound on how much of the log tail recent() will read. */
+    tailBytes?: number;
 }
 export interface PeonLogEntry {
     id: string;
@@ -9,9 +13,25 @@ export interface PeonLogEntry {
 }
 export declare class PeonLogger {
     private readonly logFile;
+    private readonly maxBytes;
+    private readonly tailBytes;
     private writeQueue;
+    private bytesWritten;
+    private sizeKnown;
     constructor(options?: PeonLoggerOptions);
     log(type: string, fields?: Record<string, unknown>): Promise<PeonLogEntry>;
+    /**
+     * Newest-first entries from the tail of the log. Cost is bounded by
+     * `tailBytes`, not by the size of the file, so this stays flat as the log
+     * grows. Entries older than the tail window are not visible here — the log
+     * file itself (and its rotated siblings) remain the full record.
+     */
     recent(limit?: number): Promise<PeonLogEntry[]>;
+    private readTail;
+    /**
+     * Move the live log aside once it exceeds maxBytes. History is preserved in a
+     * timestamped sibling rather than truncated, so nothing is lost.
+     */
+    private rotateIfNeeded;
     private enqueueWrite;
 }