@gamaze/hicortex 0.16.5 → 0.16.6

package/dist/llm.d.ts

@@ -31,6 +31,10 @@ export interface LlmConfig {
     enableThinking?: boolean;
     /** Context window for the ollama fast tier (completeOllama). Falls back to 2048. */
     numCtx?: number;
+    /** Flush ollama memory every N ollama calls (0 = off). See HicortexConfig.ollamaFlushEvery. */
+    ollamaFlushEvery?: number;
+    /** Ms to wait after an ollama flush for the runner to release. */
+    ollamaFlushWaitMs?: number;
     /** Optional separate endpoint for reflect-tier LLM (e.g. remote Ollama with larger model). */
     reflectBaseUrl?: string;
     reflectApiKey?: string;
@@ -212,6 +216,7 @@ export declare class RateLimitError extends Error {
 }
 export declare class LlmClient {
     private config;
+    private ollamaCallCount;
     constructor(config: LlmConfig);
     /** Endpoint identity for shared rate-limit state (provider + base URL). */
     private get endpointKey();
@@ -261,6 +266,14 @@ export declare class LlmClient {
      * Ollama: use /api/generate with think:false (important for qwen3.5 models).
      */
     private completeOllama;
+    /**
+     * Flush ollama's accumulated memory: unload the model (keep_alive:0) so the
+     * runner exits + releases its per-request RSS growth, then wait for the release
+     * before the next call reloads fresh. The runner takes >90 s to exit after
+     * keep_alive:0 (measured), so the wait is generous (ollamaFlushWaitMs, default
+     * 180 s). Best-effort — a flush failure just means no release this cycle.
+     */
+    private flushOllama;
     /**
      * Anthropic Messages API (/v1/messages).
      * Auth via x-api-key header.

package/dist/llm.js

@@ -211,6 +211,12 @@ function applyTierTuningOverlay(llmConfig, savedConfig) {
     if (savedConfig.numCtx !== undefined) {
         llmConfig.numCtx = (0, config_read_js_1.readPositiveConfig)(savedConfig, "numCtx", 2048);
     }
+    if (savedConfig.ollamaFlushEvery !== undefined) {
+        llmConfig.ollamaFlushEvery = (0, config_read_js_1.readPositiveConfig)(savedConfig, "ollamaFlushEvery", 0);
+    }
+    if (savedConfig.ollamaFlushWaitMs !== undefined) {
+        llmConfig.ollamaFlushWaitMs = (0, config_read_js_1.readPositiveConfig)(savedConfig, "ollamaFlushWaitMs", 180000);
+    }
 }
 /**
  * Resolve an LlmConfig from a saved ~/.hicortex/config.json object.
@@ -511,6 +517,7 @@ exports.RateLimitError = RateLimitError;
 const rateLimitedUntilByEndpoint = new Map();
 class LlmClient {
     config;
+    ollamaCallCount = 0;
     constructor(config) {
         this.config = config;
     }
@@ -739,8 +746,43 @@ class LlmClient {
                 catch { /* skip malformed lines */ }
             }
         }
+        // Flush ollama's accumulated memory every N calls. ollama's runner RSS grows
+        // ~171 MB/call and isn't freed between requests — on RAM-constrained boxes
+        // this swap-thrashes long consolidations. After the Nth call, unload the
+        // model (keep_alive:0) + wait for the runner to exit + release, so the next
+        // call reloads fresh (low RSS) instead of accumulating to thrash. Opt-in via
+        // ollamaFlushEvery (0 = off).
+        const flushEvery = this.config.ollamaFlushEvery ?? 0;
+        if (flushEvery > 0) {
+            this.ollamaCallCount++;
+            if (this.ollamaCallCount >= flushEvery) {
+                await this.flushOllama(model);
+                this.ollamaCallCount = 0;
+            }
+        }
         return result.trim();
     }
+    /**
+     * Flush ollama's accumulated memory: unload the model (keep_alive:0) so the
+     * runner exits + releases its per-request RSS growth, then wait for the release
+     * before the next call reloads fresh. The runner takes >90 s to exit after
+     * keep_alive:0 (measured), so the wait is generous (ollamaFlushWaitMs, default
+     * 180 s). Best-effort — a flush failure just means no release this cycle.
+     */
+    async flushOllama(model) {
+        const url = `${this.config.baseUrl.replace(/\/$/, "")}/api/generate`;
+        try {
+            await fetch(url, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ model, keep_alive: 0 }),
+                signal: AbortSignal.timeout(60_000),
+            });
+        }
+        catch { /* best-effort flush */ }
+        const waitMs = this.config.ollamaFlushWaitMs ?? 180_000;
+        await new Promise((r) => setTimeout(r, waitMs));
+    }
     /**
      * Anthropic Messages API (/v1/messages).
      * Auth via x-api-key header.

package/dist/types.d.ts

@@ -313,6 +313,23 @@ export interface HicortexConfig {
      * scoring prompt actually needs more.
      */
     numCtx?: number;
+    /**
+     * Flush ollama's accumulated memory every N ollama calls — workaround for
+     * ollama's per-request memory growth (the runner's RSS climbs ~171 MB/call and
+     * isn't freed between requests), which swap-thrashes RAM-constrained boxes
+     * during long consolidations. Default 0 (off). When >0, every Nth ollama call
+     * triggers a `keep_alive:0` unload + an `ollamaFlushWaitMs` pause for the
+     * runner to exit + release, then the next call reloads fresh. N=15 caps a
+     * cycle at ~2.5 GB. Opt-in — set e.g. 15 on constrained boxes.
+     */
+    ollamaFlushEvery?: number;
+    /**
+     * Milliseconds to wait after an ollama flush (`keep_alive:0`) for the runner
+     * to exit + release its accumulated memory before the next call reloads.
+     * Default 180000 (3 min — the runner takes >90 s to exit after keep_alive:0;
+     * doubled for margin). Only relevant when `ollamaFlushEvery` > 0.
+     */
+    ollamaFlushWaitMs?: number;
 }
 /** A config-owned life-sphere domain (see HicortexConfig.domains). */
 export interface DomainDef {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gamaze/hicortex",
-  "version": "0.16.5",
+  "version": "0.16.6",
   "description": "Self-learning memory for AI agents — experience captured automatically, distilled into lessons overnight, shared across your whole fleet. Works with Hermes, OpenClaw, Claude Code, and Pi.",
   "main": "dist/index.js",
   "bin": {