@poolzin/pool-bot 2026.2.0 → 2026.2.2

package/dist/config/sessions/store.js

@@ -1,11 +1,16 @@
+import JSON5 from "json5";
 import crypto from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
-import JSON5 from "json5";
-import { getFileMtimeMs, isCacheEnabled, resolveCacheTtlMs } from "../cache-utils.js";
+import { parseByteSize } from "../../cli/parse-bytes.js";
+import { parseDurationMs } from "../../cli/parse-duration.js";
+import { createSubsystemLogger } from "../../logging/subsystem.js";
 import { deliveryContextFromSession, mergeDeliveryContext, normalizeDeliveryContext, normalizeSessionDeliveryFields, } from "../../utils/delivery-context.js";
+import { getFileMtimeMs, isCacheEnabled, resolveCacheTtlMs } from "../cache-utils.js";
+import { loadConfig } from "../config.js";
 import { deriveSessionMetaPatch } from "./metadata.js";
 import { mergeSessionEntry } from "./types.js";
+const log = createSubsystemLogger("sessions/store");
 const SESSION_STORE_CACHE = new Map();
 const DEFAULT_SESSION_STORE_TTL_MS = 45_000; // 45 seconds (between 30-60s)
 function isSessionStoreRecord(value) {
@@ -29,7 +34,14 @@ function invalidateSessionStoreCache(storePath) {
     SESSION_STORE_CACHE.delete(storePath);
 }
 function normalizeSessionEntryDelivery(entry) {
-    const normalized = normalizeSessionDeliveryFields(entry);
+    const normalized = normalizeSessionDeliveryFields({
+        channel: entry.channel,
+        lastChannel: entry.lastChannel,
+        lastTo: entry.lastTo,
+        lastAccountId: entry.lastAccountId,
+        lastThreadId: entry.lastThreadId ?? entry.deliveryContext?.threadId ?? entry.origin?.threadId,
+        deliveryContext: entry.deliveryContext,
+    });
     const nextDelivery = normalized.deliveryContext;
     const sameDelivery = (entry.deliveryContext?.channel ?? undefined) === nextDelivery?.channel &&
         (entry.deliveryContext?.to ?? undefined) === nextDelivery?.to &&
@@ -39,8 +51,9 @@ function normalizeSessionEntryDelivery(entry) {
         entry.lastTo === normalized.lastTo &&
         entry.lastAccountId === normalized.lastAccountId &&
         entry.lastThreadId === normalized.lastThreadId;
-    if (sameDelivery && sameLast)
+    if (sameDelivery && sameLast) {
         return entry;
+    }
     return {
         ...entry,
         deliveryContext: nextDelivery,
@@ -50,10 +63,19 @@ function normalizeSessionEntryDelivery(entry) {
         lastThreadId: normalized.lastThreadId,
     };
 }
+function removeThreadFromDeliveryContext(context) {
+    if (!context || context.threadId == null) {
+        return context;
+    }
+    const next = { ...context };
+    delete next.threadId;
+    return next;
+}
 function normalizeSessionStore(store) {
     for (const [key, entry] of Object.entries(store)) {
-        if (!entry)
+        if (!entry) {
             continue;
+        }
         const normalized = normalizeSessionEntryDelivery(entry);
         if (normalized !== entry) {
             store[key] = normalized;
@@ -92,8 +114,9 @@ export function loadSessionStore(storePath, opts = {}) {
     }
     // Best-effort migration: message provider → channel naming.
     for (const entry of Object.values(store)) {
-        if (!entry || typeof entry !== "object")
+        if (!entry || typeof entry !== "object") {
             continue;
+        }
         const rec = entry;
         if (typeof rec.channel !== "string" && typeof rec.provider === "string") {
             rec.channel = rec.provider;
@@ -132,10 +155,233 @@ export function readSessionUpdatedAt(params) {
         return undefined;
     }
 }
-async function saveSessionStoreUnlocked(storePath, store) {
+// ============================================================================
+// Session Store Pruning, Capping & File Rotation
+// ============================================================================
+const DEFAULT_SESSION_PRUNE_AFTER_MS = 30 * 24 * 60 * 60 * 1000;
+const DEFAULT_SESSION_MAX_ENTRIES = 500;
+const DEFAULT_SESSION_ROTATE_BYTES = 10_485_760; // 10 MB
+const DEFAULT_SESSION_MAINTENANCE_MODE = "warn";
+function resolvePruneAfterMs(maintenance) {
+    const raw = maintenance?.pruneAfter ?? maintenance?.pruneDays;
+    if (raw === undefined || raw === null || raw === "") {
+        return DEFAULT_SESSION_PRUNE_AFTER_MS;
+    }
+    try {
+        return parseDurationMs(String(raw).trim(), { defaultUnit: "d" });
+    }
+    catch {
+        return DEFAULT_SESSION_PRUNE_AFTER_MS;
+    }
+}
+function resolveRotateBytes(maintenance) {
+    const raw = maintenance?.rotateBytes;
+    if (raw === undefined || raw === null || raw === "") {
+        return DEFAULT_SESSION_ROTATE_BYTES;
+    }
+    try {
+        return parseByteSize(String(raw).trim(), { defaultUnit: "b" });
+    }
+    catch {
+        return DEFAULT_SESSION_ROTATE_BYTES;
+    }
+}
+/**
+ * Resolve maintenance settings from poolbot.json (`session.maintenance`).
+ * Falls back to built-in defaults when config is missing or unset.
+ */
+export function resolveMaintenanceConfig() {
+    let maintenance;
+    try {
+        maintenance = loadConfig().session?.maintenance;
+    }
+    catch {
+        // Config may not be available (e.g. in tests). Use defaults.
+    }
+    return {
+        mode: maintenance?.mode ?? DEFAULT_SESSION_MAINTENANCE_MODE,
+        pruneAfterMs: resolvePruneAfterMs(maintenance),
+        maxEntries: maintenance?.maxEntries ?? DEFAULT_SESSION_MAX_ENTRIES,
+        rotateBytes: resolveRotateBytes(maintenance),
+    };
+}
+/**
+ * Remove entries whose `updatedAt` is older than the configured threshold.
+ * Entries without `updatedAt` are kept (cannot determine staleness).
+ * Mutates `store` in-place.
+ */
+export function pruneStaleEntries(store, overrideMaxAgeMs, opts = {}) {
+    const maxAgeMs = overrideMaxAgeMs ?? resolveMaintenanceConfig().pruneAfterMs;
+    const cutoffMs = Date.now() - maxAgeMs;
+    let pruned = 0;
+    for (const [key, entry] of Object.entries(store)) {
+        if (entry?.updatedAt != null && entry.updatedAt < cutoffMs) {
+            delete store[key];
+            pruned++;
+        }
+    }
+    if (pruned > 0 && opts.log !== false) {
+        log.info("pruned stale session entries", { pruned, maxAgeMs });
+    }
+    return pruned;
+}
+/**
+ * Cap the store to the N most recently updated entries.
+ * Entries without `updatedAt` are sorted last (removed first when over limit).
+ * Mutates `store` in-place.
+ */
+function getEntryUpdatedAt(entry) {
+    return entry?.updatedAt ?? Number.NEGATIVE_INFINITY;
+}
+export function getActiveSessionMaintenanceWarning(params) {
+    const activeSessionKey = params.activeSessionKey.trim();
+    if (!activeSessionKey) {
+        return null;
+    }
+    const activeEntry = params.store[activeSessionKey];
+    if (!activeEntry) {
+        return null;
+    }
+    const now = params.nowMs ?? Date.now();
+    const cutoffMs = now - params.pruneAfterMs;
+    const wouldPrune = activeEntry.updatedAt != null ? activeEntry.updatedAt < cutoffMs : false;
+    const keys = Object.keys(params.store);
+    const wouldCap = keys.length > params.maxEntries &&
+        keys
+            .toSorted((a, b) => getEntryUpdatedAt(params.store[b]) - getEntryUpdatedAt(params.store[a]))
+            .slice(params.maxEntries)
+            .includes(activeSessionKey);
+    if (!wouldPrune && !wouldCap) {
+        return null;
+    }
+    return {
+        activeSessionKey,
+        activeUpdatedAt: activeEntry.updatedAt,
+        totalEntries: keys.length,
+        pruneAfterMs: params.pruneAfterMs,
+        maxEntries: params.maxEntries,
+        wouldPrune,
+        wouldCap,
+    };
+}
+export function capEntryCount(store, overrideMax, opts = {}) {
+    const maxEntries = overrideMax ?? resolveMaintenanceConfig().maxEntries;
+    const keys = Object.keys(store);
+    if (keys.length <= maxEntries) {
+        return 0;
+    }
+    // Sort by updatedAt descending; entries without updatedAt go to the end (removed first).
+    const sorted = keys.toSorted((a, b) => {
+        const aTime = getEntryUpdatedAt(store[a]);
+        const bTime = getEntryUpdatedAt(store[b]);
+        return bTime - aTime;
+    });
+    const toRemove = sorted.slice(maxEntries);
+    for (const key of toRemove) {
+        delete store[key];
+    }
+    if (opts.log !== false) {
+        log.info("capped session entry count", { removed: toRemove.length, maxEntries });
+    }
+    return toRemove.length;
+}
+async function getSessionFileSize(storePath) {
+    try {
+        const stat = await fs.promises.stat(storePath);
+        return stat.size;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Rotate the sessions file if it exceeds the configured size threshold.
+ * Renames the current file to `sessions.json.bak.{timestamp}` and cleans up
+ * old rotation backups, keeping only the 3 most recent `.bak.*` files.
+ */
+export async function rotateSessionFile(storePath, overrideBytes) {
+    const maxBytes = overrideBytes ?? resolveMaintenanceConfig().rotateBytes;
+    // Check current file size (file may not exist yet).
+    const fileSize = await getSessionFileSize(storePath);
+    if (fileSize == null) {
+        return false;
+    }
+    if (fileSize <= maxBytes) {
+        return false;
+    }
+    // Rotate: rename current file to .bak.{timestamp}
+    const backupPath = `${storePath}.bak.${Date.now()}`;
+    try {
+        await fs.promises.rename(storePath, backupPath);
+        log.info("rotated session store file", {
+            backupPath: path.basename(backupPath),
+            sizeBytes: fileSize,
+        });
+    }
+    catch {
+        // If rename fails (e.g. file disappeared), skip rotation.
+        return false;
+    }
+    // Clean up old backups — keep only the 3 most recent .bak.* files.
+    try {
+        const dir = path.dirname(storePath);
+        const baseName = path.basename(storePath);
+        const files = await fs.promises.readdir(dir);
+        const backups = files
+            .filter((f) => f.startsWith(`${baseName}.bak.`))
+            .toSorted()
+            .toReversed();
+        const maxBackups = 3;
+        if (backups.length > maxBackups) {
+            const toDelete = backups.slice(maxBackups);
+            for (const old of toDelete) {
+                await fs.promises.unlink(path.join(dir, old)).catch(() => undefined);
+            }
+            log.info("cleaned up old session store backups", { deleted: toDelete.length });
+        }
+    }
+    catch {
+        // Best-effort cleanup; don't fail the write.
+    }
+    return true;
+}
+async function saveSessionStoreUnlocked(storePath, store, opts) {
     // Invalidate cache on write to ensure consistency
     invalidateSessionStoreCache(storePath);
     normalizeSessionStore(store);
+    if (!opts?.skipMaintenance) {
+        // Resolve maintenance config once (avoids repeated loadConfig() calls).
+        const maintenance = resolveMaintenanceConfig();
+        const shouldWarnOnly = maintenance.mode === "warn";
+        if (shouldWarnOnly) {
+            const activeSessionKey = opts?.activeSessionKey?.trim();
+            if (activeSessionKey) {
+                const warning = getActiveSessionMaintenanceWarning({
+                    store,
+                    activeSessionKey,
+                    pruneAfterMs: maintenance.pruneAfterMs,
+                    maxEntries: maintenance.maxEntries,
+                });
+                if (warning) {
+                    log.warn("session maintenance would evict active session; skipping enforcement", {
+                        activeSessionKey: warning.activeSessionKey,
+                        wouldPrune: warning.wouldPrune,
+                        wouldCap: warning.wouldCap,
+                        pruneAfterMs: warning.pruneAfterMs,
+                        maxEntries: warning.maxEntries,
+                    });
+                    await opts?.onWarn?.(warning);
+                }
+            }
+        }
+        else {
+            // Prune stale entries and cap total count before serializing.
+            pruneStaleEntries(store, maintenance.pruneAfterMs);
+            capEntryCount(store, maintenance.maxEntries);
+            // Rotate the on-disk file if it exceeds the size threshold.
+            await rotateSessionFile(storePath, maintenance.rotateBytes);
+        }
+    }
     await fs.promises.mkdir(path.dirname(storePath), { recursive: true });
     const json = JSON.stringify(store, null, 2);
     // Windows: avoid atomic rename swaps (can be flaky under concurrent access).
@@ -148,8 +394,9 @@ async function saveSessionStoreUnlocked(storePath, store) {
             const code = err && typeof err === "object" && "code" in err
                 ? String(err.code)
                 : null;
-            if (code === "ENOENT")
+            if (code === "ENOENT") {
                 return;
+            }
             throw err;
         }
         return;
@@ -177,8 +424,9 @@ async function saveSessionStoreUnlocked(storePath, store) {
                 const code2 = err2 && typeof err2 === "object" && "code" in err2
                     ? String(err2.code)
                     : null;
-                if (code2 === "ENOENT")
+                if (code2 === "ENOENT") {
                     return;
+                }
                 throw err2;
             }
             return;
@@ -189,17 +437,17 @@ async function saveSessionStoreUnlocked(storePath, store) {
         await fs.promises.rm(tmp, { force: true });
     }
 }
-export async function saveSessionStore(storePath, store) {
+export async function saveSessionStore(storePath, store, opts) {
     await withSessionStoreLock(storePath, async () => {
-        await saveSessionStoreUnlocked(storePath, store);
+        await saveSessionStoreUnlocked(storePath, store, opts);
     });
 }
-export async function updateSessionStore(storePath, mutator) {
+export async function updateSessionStore(storePath, mutator, opts) {
     return await withSessionStoreLock(storePath, async () => {
         // Always re-read inside the lock to avoid clobbering concurrent writers.
         const store = loadSessionStore(storePath, { skipCache: true });
         const result = await mutator(store);
-        await saveSessionStoreUnlocked(storePath, store);
+        await saveSessionStoreUnlocked(storePath, store, opts);
         return result;
     });
 }
@@ -235,11 +483,12 @@ async function withSessionStoreLock(storePath, fn, opts = {}) {
                 await new Promise((r) => setTimeout(r, pollIntervalMs));
                 continue;
             }
-            if (code !== "EEXIST")
+            if (code !== "EEXIST") {
                 throw err;
+            }
             const now = Date.now();
             if (now - startedAt > timeoutMs) {
-                throw new Error(`timeout acquiring session store lock: ${lockPath}`);
+                throw new Error(`timeout acquiring session store lock: ${lockPath}`, { cause: err });
             }
             // Best-effort stale lock eviction (e.g. crashed process).
             try {
@@ -268,14 +517,16 @@ export async function updateSessionStoreEntry(params) {
     return await withSessionStoreLock(storePath, async () => {
         const store = loadSessionStore(storePath);
         const existing = store[sessionKey];
-        if (!existing)
+        if (!existing) {
             return null;
+        }
         const patch = await update(existing);
-        if (!patch)
+        if (!patch) {
             return existing;
+        }
         const next = mergeSessionEntry(existing, patch);
         store[sessionKey] = next;
-        await saveSessionStoreUnlocked(storePath, store);
+        await saveSessionStoreUnlocked(storePath, store, { activeSessionKey: sessionKey });
         return next;
     });
 }
@@ -290,14 +541,16 @@ export async function recordSessionMetaFromInbound(params) {
             existing,
             groupResolution: params.groupResolution,
         });
-        if (!patch)
+        if (!patch) {
             return existing ?? null;
-        if (!existing && !createIfMissing)
+        }
+        if (!existing && !createIfMissing) {
             return null;
+        }
         const next = mergeSessionEntry(existing, patch);
         store[sessionKey] = next;
         return next;
-    });
+    }, { activeSessionKey: sessionKey });
 }
 export async function updateLastRoute(params) {
     const { storePath, sessionKey, channel, to, accountId, threadId, ctx } = params;
@@ -313,7 +566,22 @@ export async function updateLastRoute(params) {
             threadId,
         });
         const mergedInput = mergeDeliveryContext(explicitContext, inlineContext);
-        const merged = mergeDeliveryContext(mergedInput, deliveryContextFromSession(existing));
+        const explicitDeliveryContext = params.deliveryContext;
+        const explicitThreadFromDeliveryContext = explicitDeliveryContext != null &&
+            Object.prototype.hasOwnProperty.call(explicitDeliveryContext, "threadId")
+            ? explicitDeliveryContext.threadId
+            : undefined;
+        const explicitThreadValue = explicitThreadFromDeliveryContext ??
+            (threadId != null && threadId !== "" ? threadId : undefined);
+        const explicitRouteProvided = Boolean(explicitContext?.channel ||
+            explicitContext?.to ||
+            inlineContext?.channel ||
+            inlineContext?.to);
+        const clearThreadFromFallback = explicitRouteProvided && explicitThreadValue == null;
+        const fallbackContext = clearThreadFromFallback
+            ? removeThreadFromDeliveryContext(deliveryContextFromSession(existing))
+            : deliveryContextFromSession(existing);
+        const merged = mergeDeliveryContext(mergedInput, fallbackContext);
         const normalized = normalizeSessionDeliveryFields({
             deliveryContext: {
                 channel: merged?.channel,
@@ -340,7 +608,7 @@ export async function updateLastRoute(params) {
         };
         const next = mergeSessionEntry(existing, metaPatch ? { ...basePatch, ...metaPatch } : basePatch);
         store[sessionKey] = next;
-        await saveSessionStoreUnlocked(storePath, store);
+        await saveSessionStoreUnlocked(storePath, store, { activeSessionKey: sessionKey });
         return next;
     });
 }

package/dist/config/zod-schema.agent-defaults.js

@@ -23,6 +23,8 @@ export const AgentDefaultsSchema = z
         alias: z.string().optional(),
         /** Provider-specific API parameters (e.g., GLM-4.7 thinking mode). */
         params: z.record(z.string(), z.unknown()).optional(),
+        /** Enable streaming for this model (default: true, false for Ollama to avoid SDK issue #1205). */
+        streaming: z.boolean().optional(),
     })
         .strict())
         .optional(),
@@ -135,6 +137,7 @@ export const AgentDefaultsSchema = z
                 .strict(),
         ])
             .optional(),
+        thinking: z.string().optional(),
     })
         .strict()
         .optional(),

package/dist/config/zod-schema.agent-runtime.js

@@ -17,6 +17,7 @@ export const HeartbeatSchema = z
     includeReasoning: z.boolean().optional(),
     target: z.string().optional(),
     to: z.string().optional(),
+    accountId: z.string().optional(),
     prompt: z.string().optional(),
     ackMaxChars: z.number().int().nonnegative().optional(),
 })
@@ -278,13 +279,16 @@ export const MemorySearchSchema = z
     .object({
     enabled: z.boolean().optional(),
     sources: z.array(z.union([z.literal("memory"), z.literal("sessions")])).optional(),
+    extraPaths: z.array(z.string()).optional(),
     experimental: z
         .object({
         sessionMemory: z.boolean().optional(),
     })
         .strict()
         .optional(),
-    provider: z.union([z.literal("openai"), z.literal("local"), z.literal("gemini")]).optional(),
+    provider: z
+        .union([z.literal("openai"), z.literal("local"), z.literal("gemini"), z.literal("voyage")])
+        .optional(),
     remote: z
         .object({
         baseUrl: z.string().optional(),
@@ -304,7 +308,13 @@ export const MemorySearchSchema = z
         .strict()
         .optional(),
     fallback: z
-        .union([z.literal("openai"), z.literal("gemini"), z.literal("local"), z.literal("none")])
+        .union([
+        z.literal("openai"),
+        z.literal("gemini"),
+        z.literal("local"),
+        z.literal("voyage"),
+        z.literal("none"),
+    ])
         .optional(),
     model: z.string().optional(),
     local: z
@@ -414,6 +424,7 @@ export const AgentEntrySchema = z
                 .strict(),
         ])
             .optional(),
+        thinking: z.string().optional(),
     })
         .strict()
         .optional(),