peon-mem 1.0.6 → 1.0.7

package/dist/daemon.d.ts

@@ -1,8 +1,11 @@
+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,6 +7,7 @@ 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";
@@ -158,6 +159,53 @@ 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
@@ -203,7 +251,8 @@ export async function startPeonDaemon(options = {}) {
             sendJson(response, 403, { error: "forbidden: non-local request origin" });
             return;
         }
-        const noisy = NOISY_LOG_PATHS.has(requestUrl.pathname);
+        const noisy = NOISY_LOG_PATHS.has(requestUrl.pathname) ||
+            (requestMethod === "GET" && requestUrl.pathname.startsWith("/roundtable/"));
         if (!noisy) {
             await logger.log("request_in", {
                 requestId,
@@ -213,7 +262,36 @@ export async function startPeonDaemon(options = {}) {
             });
         }
         try {
-            const result = await routeRequest(request, tools, activeSessions, monitorState, logger, projectRegistry);
+            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);
             if ("html" in result) {
                 sendHtml(response, result.status ?? 200, result.html);
             }
@@ -344,12 +422,15 @@ 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) {
+async function routeRequest(request, tools, activeSessions, monitorState, logger, projectRegistry, roundtable) {
     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() };
     }
@@ -359,6 +440,56 @@ 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,8 @@ export interface SyncResult {
     reused: number;
     pruned: number;
 }
+/** Test helper: forget learned widths, simulating a fresh daemon process. */
+export declare function resetEmbeddingDimensionCache(): void;
 export declare class EmbeddingStore {
     private readonly filePath;
     private cache?;

package/dist/embedding-store.js

@@ -1,6 +1,12 @@
 import { mkdir, readFile, rename, stat, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { contentHash } from "./embeddings.js";
+/** Real output width per embedding model, learned once per process. */
+const modelDimensions = new Map();
+/** Test helper: forget learned widths, simulating a fresh daemon process. */
+export function resetEmbeddingDimensionCache() {
+    modelDimensions.clear();
+}
 export class EmbeddingStore {
     filePath;
     // mtime-keyed cache so the (multi-MB) sidecar isn't re-read+parsed on every prompt's
@@ -56,11 +62,36 @@ export class EmbeddingStore {
         const existing = await this.load();
         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;
+        };
+        let expectedDim = modelDimensions.get(client.model) ?? 0;
+        if (expectedDim === 0 && records.length > 0 && records.every((record) => matchesStored(record))) {
+            try {
+                const probe = await client.embed([embeddingText(records[0])]);
+                if (!client.degraded && probe[0]?.length) {
+                    expectedDim = probe[0].length;
+                    modelDimensions.set(client.model, expectedDim);
+                }
+            }
+            catch {
+                expectedDim = 0; // cannot probe — fall back to model+hash validity only
+            }
+        }
+        const valid = (prior) => Boolean(prior) && (expectedDim === 0 || prior.vector.length === expectedDim);
         const toCompute = [];
         let reused = 0;
         for (const record of records) {
-            const prior = existing.get(record.id);
-            if (prior && prior.model === client.model && prior.hash === contentHash(embeddingText(record))) {
+            if (valid(matchesStored(record))) {
                 reused += 1;
             }
             else {
@@ -69,15 +100,28 @@ export class EmbeddingStore {
         }
         const result = new Map();
         for (const record of records) {
-            const prior = existing.get(record.id);
-            if (prior && prior.model === client.model && prior.hash === contentHash(embeddingText(record))) {
+            const prior = matchesStored(record);
+            if (valid(prior))
                 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.
+                if (client.degraded) {
+                    const degradedById = new Map();
+                    for (const [id, stored] of result)
+                        degradedById.set(id, stored.vector);
+                    toCompute.forEach((record, i) => {
+                        const vector = vectors[i];
+                        if (vector)
+                            degradedById.set(record.id, vector);
+                    });
+                    return { vectorById: degradedById, computed: 0, reused, pruned };
+                }
                 toCompute.forEach((record, i) => {
                     result.set(record.id, {
                         id: record.id,
@@ -87,6 +131,9 @@ export class EmbeddingStore {
                     });
                 });
                 computed = toCompute.length;
+                const width = vectors[0]?.length ?? 0;
+                if (width > 0)
+                    modelDimensions.set(client.model, width);
             }
             catch {
                 // On a hard failure, keep whatever we already had and continue lexical-only.

package/dist/embeddings.d.ts

@@ -81,6 +81,15 @@ export declare class FallbackEmbeddingClient implements EmbeddingClient {
     private readonly fallback;
     private readonly onFallback?;
     readonly model: string;
+    /**
+     * True when the most recent embed() degraded to the fallback. The vectors it
+     * returns are a different model AND a different width, so persisting them under
+     * the primary's name makes them indistinguishable from real ones — every later
+     * sync then "reuses" trigram vectors as if they were embeddings, and retrieval
+     * silently scores them 0 (cosineSimilarity returns 0 on a length mismatch).
+     * Callers that persist vectors must check this and skip writing.
+     */
+    degraded: boolean;
     constructor(primary: EmbeddingClient, fallback?: EmbeddingClient, onFallback?: ((error: unknown) => void) | undefined);
     embed(texts: string[]): Promise<EmbeddingVector[]>;
 }
@@ -90,4 +99,25 @@ export interface CreateEmbeddingClientOptions {
     onFallback?: (error: unknown) => void;
 }
 /** Build the embedding client implied by config, or null when embeddings are off. */
+/**
+ * What was asked for versus what will actually run.
+ *
+ * Peon degrades to deterministic local trigram embeddings whenever the configured
+ * embedder is unavailable. That is deliberate — retrieval keeps working — but it was
+ * silent, and a silent downgrade is indistinguishable from working correctly while
+ * semantic recall quietly collapses. Two real incidents: an Ollama blip embedding 30k+
+ * records with trigram vectors, and a script whose .env was not found resolving to
+ * "local" with no warning at all.
+ */
+export interface EmbeddingPlan {
+    intended: PeonConfig["embeddingMode"];
+    effective: "off" | "local" | "api" | "ollama";
+    downgraded: boolean;
+    reason?: string;
+}
+/** Only the fields the decision actually depends on, matching the client factory. */
+export type EmbeddingPlanInput = Pick<PeonConfig, "embeddingMode" | "embeddingModel" | "openRouterApiKey" | "provider" | "llmApiKey">;
+export declare function resolveEmbeddingPlan(config: EmbeddingPlanInput): EmbeddingPlan;
+/** Test helper: forget which downgrade warnings have already been emitted. */
+export declare function resetEmbeddingWarnings(): void;
 export declare function createEmbeddingClient(options: CreateEmbeddingClientOptions): EmbeddingClient | null;

package/dist/embeddings.js

@@ -290,6 +290,15 @@ export class FallbackEmbeddingClient {
     fallback;
     onFallback;
     model;
+    /**
+     * True when the most recent embed() degraded to the fallback. The vectors it
+     * returns are a different model AND a different width, so persisting them under
+     * the primary's name makes them indistinguishable from real ones — every later
+     * sync then "reuses" trigram vectors as if they were embeddings, and retrieval
+     * silently scores them 0 (cosineSimilarity returns 0 on a length mismatch).
+     * Callers that persist vectors must check this and skip writing.
+     */
+    degraded = false;
     constructor(primary, fallback = new LocalEmbeddingClient(), onFallback) {
         this.primary = primary;
         this.fallback = fallback;
@@ -298,19 +307,73 @@ export class FallbackEmbeddingClient {
     }
     async embed(texts) {
         try {
-            return await this.primary.embed(texts);
+            const vectors = await this.primary.embed(texts);
+            this.degraded = false;
+            return vectors;
         }
         catch (error) {
             this.onFallback?.(error);
+            this.degraded = true;
             return this.fallback.embed(texts);
         }
     }
 }
-/** Build the embedding client implied by config, or null when embeddings are off. */
+export function resolveEmbeddingPlan(config) {
+    const intended = config.embeddingMode;
+    if (intended === "off")
+        return { intended, effective: "off", downgraded: false };
+    if (intended === "local")
+        return { intended, effective: "local", downgraded: false };
+    if (intended === "ollama") {
+        // Reachability cannot be known at construction time; a dead server surfaces at
+        // the first embed() as a degraded run, which the store refuses to persist.
+        return { intended, effective: "ollama", downgraded: false };
+    }
+    const apiKey = config.llmApiKey ?? config.openRouterApiKey;
+    if (!apiKey) {
+        return { intended, effective: "local", downgraded: true, reason: "no API key/credentials configured" };
+    }
+    if (!config.embeddingModel) {
+        return { intended, effective: "local", downgraded: true, reason: "PEON_EMBEDDING_MODEL is not set" };
+    }
+    if (config.provider === "anthropic") {
+        return { intended, effective: "local", downgraded: true, reason: "Anthropic has no embeddings API" };
+    }
+    return { intended, effective: "api", downgraded: false };
+}
+/** Warn once per distinct reason, so a long-lived daemon does not spam its log. */
+const warnedDowngrades = new Set();
+function warnOnce(plan) {
+    if (!plan.downgraded || !plan.reason)
+        return;
+    if (warnedDowngrades.has(plan.reason))
+        return;
+    warnedDowngrades.add(plan.reason);
+    console.warn(`[peon] embedding mode "${plan.intended}" is not available (${plan.reason}); ` +
+        `falling back to local trigram embeddings. Semantic recall will be much weaker — ` +
+        `set PEON_EMBEDDING_MODE=local to silence this, or fix the configuration.`);
+}
+/** Test helper: forget which downgrade warnings have already been emitted. */
+export function resetEmbeddingWarnings() {
+    warnedDowngrades.clear();
+}
 export function createEmbeddingClient(options) {
     const { config } = options;
+    warnOnce(resolveEmbeddingPlan(config));
     if (config.embeddingMode === "off")
         return null;
+    // No caller ever supplied onFallback, so a runtime degrade (embedding server down)
+    // was completely silent. Default to warning once per process: the vectors from that
+    // run are trigram, not semantic, and the operator needs to know retrieval got worse.
+    const onFallback = options.onFallback ??
+        ((error) => {
+            if (warnedDowngrades.has("runtime-fallback"))
+                return;
+            warnedDowngrades.add("runtime-fallback");
+            console.warn(`[peon] embedding request failed (${error instanceof Error ? error.message : String(error)}); ` +
+                `falling back to local trigram embeddings for this run. Semantic recall is degraded ` +
+                `until the embedding server is reachable again.`);
+        });
     if (config.embeddingMode === "ollama") {
         // Local semantic embeddings. Fall back to the API client (if configured) then trigram-local,
         // so a stopped Ollama service degrades instead of breaking retrieval.
@@ -319,9 +382,9 @@ export function createEmbeddingClient(options) {
             baseUrl: config.ollamaBaseUrl
         });
         const fallback = config.openRouterApiKey && config.embeddingModel && config.embeddingModel.includes("/")
-            ? new FallbackEmbeddingClient(new OpenRouterEmbeddingClient({ apiKey: config.openRouterApiKey, model: config.embeddingModel }), new LocalEmbeddingClient(), options.onFallback)
+            ? new FallbackEmbeddingClient(new OpenRouterEmbeddingClient({ apiKey: config.openRouterApiKey, model: config.embeddingModel }), new LocalEmbeddingClient(), onFallback)
             : new LocalEmbeddingClient();
-        return new FallbackEmbeddingClient(ollama, fallback, options.onFallback);
+        return new FallbackEmbeddingClient(ollama, fallback, onFallback);
     }
     const apiKey = config.llmApiKey ?? config.openRouterApiKey;
     const embeddable = config.provider !== "anthropic"; // Anthropic has no embeddings API — local fallback
@@ -331,7 +394,7 @@ export function createEmbeddingClient(options) {
             model: config.embeddingModel,
             baseUrl: config.llmBaseUrl
         });
-        return new FallbackEmbeddingClient(primary, new LocalEmbeddingClient(), options.onFallback);
+        return new FallbackEmbeddingClient(primary, new LocalEmbeddingClient(), onFallback);
     }
     // Default and "api"-without-credentials both resolve to deterministic local embeddings.
     return new LocalEmbeddingClient();