@poolzin/pool-bot 2026.2.24 → 2026.2.26

package/dist/memory/backend-config.js

@@ -8,6 +8,9 @@ const DEFAULT_CITATIONS = "auto";
 const DEFAULT_QMD_INTERVAL = "5m";
 const DEFAULT_QMD_DEBOUNCE_MS = 15_000;
 const DEFAULT_QMD_TIMEOUT_MS = 4_000;
+// Defaulting to `query` can be extremely slow on CPU-only systems (query expansion + rerank).
+// Prefer a faster mode for interactive use; users can opt into `query` for best recall.
+const DEFAULT_QMD_SEARCH_MODE = "search";
 const DEFAULT_QMD_EMBED_INTERVAL = "60m";
 const DEFAULT_QMD_COMMAND_TIMEOUT_MS = 30_000;
 const DEFAULT_QMD_UPDATE_TIMEOUT_MS = 120_000;
@@ -18,6 +21,11 @@ const DEFAULT_QMD_LIMITS = {
     maxInjectedChars: 4_000,
     timeoutMs: DEFAULT_QMD_TIMEOUT_MS,
 };
+const DEFAULT_QMD_MCPORTER = {
+    enabled: false,
+    serverName: "qmd",
+    startDaemon: true,
+};
 const DEFAULT_QMD_SCOPE = {
     default: "deny",
     rules: [
@@ -32,6 +40,9 @@ function sanitizeName(input) {
     const trimmed = lower.replace(/^-+|-+$/g, "");
     return trimmed || "collection";
 }
+function scopeCollectionBase(base, agentId) {
+    return `${base}-${sanitizeName(agentId)}`;
+}
 function ensureUniqueName(base, existing) {
     let name = sanitizeName(base);
     if (!existing.has(name)) {
@@ -108,6 +119,12 @@ function resolveLimits(raw) {
     }
     return parsed;
 }
+function resolveSearchMode(raw) {
+    if (raw === "search" || raw === "vsearch" || raw === "query") {
+        return raw;
+    }
+    return DEFAULT_QMD_SEARCH_MODE;
+}
 function resolveSessionConfig(cfg, workspaceDir) {
     const enabled = Boolean(cfg?.enabled);
     const exportDirRaw = cfg?.exportDir?.trim();
@@ -119,7 +136,7 @@ function resolveSessionConfig(cfg, workspaceDir) {
         retentionDays,
     };
 }
-function resolveCustomPaths(rawPaths, workspaceDir, existing) {
+function resolveCustomPaths(rawPaths, workspaceDir, existing, agentId) {
     if (!rawPaths?.length) {
         return [];
     }
@@ -137,7 +154,7 @@ function resolveCustomPaths(rawPaths, workspaceDir, existing) {
             return;
         }
         const pattern = entry.pattern?.trim() || "**/*.md";
-        const baseName = entry.name?.trim() || `custom-${index + 1}`;
+        const baseName = scopeCollectionBase(entry.name?.trim() || `custom-${index + 1}`, agentId);
         const name = ensureUniqueName(baseName, existing);
         collections.push({
             name,
@@ -148,7 +165,27 @@ function resolveCustomPaths(rawPaths, workspaceDir, existing) {
     });
     return collections;
 }
-function resolveDefaultCollections(include, workspaceDir, existing) {
+function resolveMcporterConfig(raw) {
+    const parsed = { ...DEFAULT_QMD_MCPORTER };
+    if (!raw) {
+        return parsed;
+    }
+    if (raw.enabled !== undefined) {
+        parsed.enabled = raw.enabled;
+    }
+    if (typeof raw.serverName === "string" && raw.serverName.trim()) {
+        parsed.serverName = raw.serverName.trim();
+    }
+    if (raw.startDaemon !== undefined) {
+        parsed.startDaemon = raw.startDaemon;
+    }
+    // When enabled, default startDaemon to true.
+    if (parsed.enabled && raw.startDaemon === undefined) {
+        parsed.startDaemon = true;
+    }
+    return parsed;
+}
+function resolveDefaultCollections(include, workspaceDir, existing, agentId) {
     if (!include) {
         return [];
     }
@@ -158,7 +195,7 @@ function resolveDefaultCollections(include, workspaceDir, existing) {
         { path: path.join(workspaceDir, "memory"), pattern: "**/*.md", base: "memory-dir" },
     ];
     return entries.map((entry) => ({
-        name: ensureUniqueName(entry.base, existing),
+        name: ensureUniqueName(scopeCollectionBase(entry.base, agentId), existing),
         path: entry.path,
         pattern: entry.pattern,
         kind: "memory",
@@ -175,14 +212,16 @@ export function resolveMemoryBackendConfig(params) {
     const includeDefaultMemory = qmdCfg?.includeDefaultMemory !== false;
     const nameSet = new Set();
     const collections = [
-        ...resolveDefaultCollections(includeDefaultMemory, workspaceDir, nameSet),
-        ...resolveCustomPaths(qmdCfg?.paths, workspaceDir, nameSet),
+        ...resolveDefaultCollections(includeDefaultMemory, workspaceDir, nameSet, params.agentId),
+        ...resolveCustomPaths(qmdCfg?.paths, workspaceDir, nameSet, params.agentId),
     ];
     const rawCommand = qmdCfg?.command?.trim() || "qmd";
     const parsedCommand = splitShellArgs(rawCommand);
     const command = parsedCommand?.[0] || rawCommand.split(/\s+/)[0] || "qmd";
     const resolved = {
         command,
+        mcporter: resolveMcporterConfig(qmdCfg?.mcporter),
+        searchMode: resolveSearchMode(qmdCfg?.searchMode),
         collections,
         includeDefaultMemory,
         sessions: resolveSessionConfig(qmdCfg?.sessions, workspaceDir),

package/dist/memory/embeddings.js

@@ -118,7 +118,9 @@ export async function createEmbeddingProvider(options) {
                     continue;
                 }
                 // Non-auth errors (e.g., network) are still fatal
-                throw new Error(message, { cause: err });
+                const wrapped = new Error(message);
+                wrapped.cause = err;
+                throw wrapped;
             }
         }
         // All providers failed due to missing API keys - return null provider for FTS-only mode
@@ -161,7 +163,9 @@ export async function createEmbeddingProvider(options) {
                     };
                 }
                 // Non-auth errors are still fatal
-                throw new Error(combinedReason, { cause: fallbackErr });
+                const wrapped = new Error(combinedReason);
+                wrapped.cause = fallbackErr;
+                throw wrapped;
             }
         }
         // No fallback configured - check if we should degrade to FTS-only
@@ -172,7 +176,9 @@ export async function createEmbeddingProvider(options) {
                 providerUnavailableReason: reason,
             };
         }
-        throw new Error(reason, { cause: primaryErr });
+        const wrapped = new Error(reason);
+        wrapped.cause = primaryErr;
+        throw wrapped;
     }
 }
 function isNodeLlamaCppMissing(err) {
@@ -199,7 +205,7 @@ function formatLocalSetupError(err) {
         "To enable local embeddings:",
         "1) Use Node 22 LTS (recommended for installs/updates)",
         missing
-            ? "2) Reinstall Poolbot (this should install node-llama-cpp): npm i -g poolbot@latest"
+            ? "2) Reinstall Pool Bot (this should install node-llama-cpp): npm i -g @poolzin/pool-bot@latest"
             : null,
         "3) If you use pnpm: pnpm approve-builds (select node-llama-cpp), then pnpm rebuild node-llama-cpp",
         ...REMOTE_EMBEDDING_PROVIDER_IDS.map((provider) => `Or set agents.defaults.memorySearch.provider = "${provider}" (remote).`),

package/dist/memory/fs-utils.js

@@ -0,0 +1,23 @@
+import fs from "node:fs/promises";
+export function isFileMissingError(err) {
+    return Boolean(err &&
+        typeof err === "object" &&
+        "code" in err &&
+        err.code === "ENOENT");
+}
+export async function statRegularFile(absPath) {
+    let stat;
+    try {
+        stat = await fs.lstat(absPath);
+    }
+    catch (err) {
+        if (isFileMissingError(err)) {
+            return { missing: true };
+        }
+        throw err;
+    }
+    if (stat.isSymbolicLink() || !stat.isFile()) {
+        throw new Error("path required");
+    }
+    return { missing: false, stat };
+}

package/dist/memory/manager-search.js

@@ -2,8 +2,9 @@ import { truncateUtf16Safe } from "../utils.js";
 import { cosineSimilarity, parseEmbedding } from "./internal.js";
 const vectorToBlob = (embedding) => Buffer.from(new Float32Array(embedding).buffer);
 export async function searchVector(params) {
-    if (params.queryVec.length === 0 || params.limit <= 0)
+    if (params.queryVec.length === 0 || params.limit <= 0) {
         return [];
+    }
     if (await params.ensureVectorReady(params.queryVec.length)) {
         const rows = params.db
             .prepare(`SELECT c.id, c.path, c.start_line, c.end_line, c.text,\n` +
@@ -37,7 +38,7 @@ export async function searchVector(params) {
     }))
         .filter((entry) => Number.isFinite(entry.score));
     return scored
-        .sort((a, b) => b.score - a.score)
+        .toSorted((a, b) => b.score - a.score)
         .slice(0, params.limit)
         .map((entry) => ({
         id: entry.chunk.id,
@@ -66,19 +67,24 @@ export function listChunks(params) {
     }));
 }
 export async function searchKeyword(params) {
-    if (params.limit <= 0)
+    if (params.limit <= 0) {
         return [];
+    }
     const ftsQuery = params.buildFtsQuery(params.query);
-    if (!ftsQuery)
+    if (!ftsQuery) {
         return [];
+    }
+    // When providerModel is undefined (FTS-only mode), search all models
+    const modelClause = params.providerModel ? " AND model = ?" : "";
+    const modelParams = params.providerModel ? [params.providerModel] : [];
     const rows = params.db
         .prepare(`SELECT id, path, source, start_line, end_line, text,\n` +
         `       bm25(${params.ftsTable}) AS rank\n` +
         `  FROM ${params.ftsTable}\n` +
-        ` WHERE ${params.ftsTable} MATCH ? AND model = ?${params.sourceFilter.sql}\n` +
+        ` WHERE ${params.ftsTable} MATCH ?${modelClause}${params.sourceFilter.sql}\n` +
         ` ORDER BY rank ASC\n` +
         ` LIMIT ?`)
-        .all(ftsQuery, params.providerModel, ...params.sourceFilter.params, params.limit);
+        .all(ftsQuery, ...modelParams, ...params.sourceFilter.params, params.limit);
     return rows.map((row) => {
         const textScore = params.bm25RankToScore(row.rank);
         return {

package/dist/memory/manager-sync-ops.js

@@ -12,6 +12,7 @@ import { DEFAULT_GEMINI_EMBEDDING_MODEL } from "./embeddings-gemini.js";
 import { DEFAULT_OPENAI_EMBEDDING_MODEL } from "./embeddings-openai.js";
 import { DEFAULT_VOYAGE_EMBEDDING_MODEL } from "./embeddings-voyage.js";
 import { createEmbeddingProvider, } from "./embeddings.js";
+import { isFileMissingError } from "./fs-utils.js";
 import { buildFileEntry, ensureDir, listMemoryFiles, normalizeExtraMemoryPaths, runWithConcurrency, } from "./internal.js";
 import { ensureMemoryIndexSchema } from "./memory-schema.js";
 import { buildSessionEntry, listSessionFilesForAgent, sessionPathForFile, } from "./session-files.js";
@@ -392,7 +393,16 @@ export class MemoryManagerSyncOps {
         if (end <= start) {
             return 0;
         }
-        const handle = await fs.open(absPath, "r");
+        let handle;
+        try {
+            handle = await fs.open(absPath, "r");
+        }
+        catch (err) {
+            if (isFileMissingError(err)) {
+                return 0;
+            }
+            throw err;
+        }
         try {
             let offset = start;
             let count = 0;
@@ -483,7 +493,7 @@ export class MemoryManagerSyncOps {
             return;
         }
         const files = await listMemoryFiles(this.workspaceDir, this.settings.extraPaths);
-        const fileEntries = await Promise.all(files.map(async (file) => buildFileEntry(file, this.workspaceDir)));
+        const fileEntries = (await Promise.all(files.map(async (file) => buildFileEntry(file, this.workspaceDir)))).filter((entry) => entry !== null);
         log.debug("memory sync: indexing memory files", {
             files: fileEntries.length,
             needsFullReindex: params.needsFullReindex,