@gamaze/hicortex 0.16.4 → 0.16.6

package/dist/llm.d.ts

@@ -29,6 +29,12 @@ export interface LlmConfig {
     maxTokens?: number;
     /** Toggle thinking on the openai-compat path for the heavy phases. Absent = no kwarg sent. */
     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;
@@ -210,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();
@@ -259,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

@@ -208,6 +208,15 @@ function applyTierTuningOverlay(llmConfig, savedConfig) {
     if (thinking !== undefined) {
         llmConfig.enableThinking = thinking;
     }
+    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.
@@ -508,6 +517,7 @@ exports.RateLimitError = RateLimitError;
 const rateLimitedUntilByEndpoint = new Map();
 class LlmClient {
     config;
+    ollamaCallCount = 0;
     constructor(config) {
         this.config = config;
     }
@@ -539,10 +549,11 @@ class LlmClient {
      */
     async completeFast(prompt, maxTokens) {
         const tokens = maxTokens ?? this.config.maxTokens ?? 2048;
-        // No `thinking` arg: scoring is excluded from the thinking toggle (it's the
-        // local fast tier; on ollama it's think:false regardless). completeFast never
-        // threads thinking, so chat_template_kwargs is never sent for scoring.
-        return this.complete(this.config.model, prompt, tokens, 600_000);
+        // Scoring is the fast tier: numCtx (default 2048, ~850-token prompts) is threaded
+        // so ONLY this tier gets the smaller context window — the heavy tiers keep 32768
+        // (preserves detectChunkSize's chunk-sizing). thinking is not threaded (scoring is
+        // excluded from the thinking toggle; ollama is think:false regardless).
+        return this.complete(this.config.model, prompt, tokens, 600_000, undefined, this.config.numCtx ?? 2048);
     }
     /**
      * Reflect-tier completion (nightly reflection, needs reasoning).
@@ -608,9 +619,14 @@ class LlmClient {
             apiKey,
             provider,
         });
+        // numCtx intentionally NOT forwarded here: only the heavy tiers route through
+        // completeWithOverride (there is no fastBaseUrl/fast-tier override), and they
+        // must land on completeOllama's 32768 default to preserve detectChunkSize. If a
+        // fast-tier override is ever added, thread numCtx here too — else the fast tier
+        // would silently revert to 32768 (the original bug, reintroduced).
         return tempClient.complete(model, prompt, maxTokens, timeoutMs, thinking);
     }
-    async complete(model, prompt, maxTokens, timeoutMs, thinking) {
+    async complete(model, prompt, maxTokens, timeoutMs, thinking, numCtx) {
         if (this.isRateLimited) {
             throw new RateLimitError(this.rateLimitedUntil - Date.now());
         }
@@ -618,7 +634,7 @@ class LlmClient {
         let lastErr;
         for (let attempt = 0; attempt <= retryDelays.length; attempt++) {
             try {
-                return await this.completeOnce(model, prompt, maxTokens, timeoutMs, thinking);
+                return await this.completeOnce(model, prompt, maxTokens, timeoutMs, thinking, numCtx);
             }
             catch (err) {
                 lastErr = err instanceof Error ? err : new Error(String(err));
@@ -635,12 +651,12 @@ class LlmClient {
         }
         throw lastErr;
     }
-    async completeOnce(model, prompt, maxTokens, timeoutMs, thinking) {
+    async completeOnce(model, prompt, maxTokens, timeoutMs, thinking, numCtx) {
         if (this.config.provider === "claude-cli") {
             return this.completeClaude(model, prompt, timeoutMs);
         }
         if (this.config.provider === "ollama") {
-            return this.completeOllama(model, prompt, maxTokens, timeoutMs);
+            return this.completeOllama(model, prompt, maxTokens, timeoutMs, numCtx);
         }
         if (this.config.provider === "anthropic") {
             return this.completeAnthropic(model, prompt, maxTokens, timeoutMs);
@@ -676,7 +692,7 @@ class LlmClient {
     /**
      * Ollama: use /api/generate with think:false (important for qwen3.5 models).
      */
-    async completeOllama(model, prompt, maxTokens, timeoutMs) {
+    async completeOllama(model, prompt, maxTokens, timeoutMs, numCtx) {
         const url = `${this.config.baseUrl.replace(/\/$/, "")}/api/generate`;
         // Ollama can take minutes to process large contexts — use streaming to avoid
         // Node.js fetch headers timeout (default ~300s kills long Ollama inferences)
@@ -688,7 +704,14 @@ class LlmClient {
                 prompt,
                 stream: true,
                 think: false,
-                options: { num_predict: maxTokens, num_ctx: 32768 },
+                // num_ctx: threaded from completeFast (the fast/scoring tier) via the numCtx
+                // param. The fast tier passes the numCtx config key (default 2048; scoring
+                // prompts are ~850 tokens) to minimize the KV/prompt-cache footprint that, at
+                // 32768, accumulated past available RAM on memory-constrained boxes during long
+                // consolidations and swap-thrashed the nightly. The heavy tiers
+                // (completeDistill/Reflect/Classify) do NOT pass numCtx → default 32768, which
+                // preserves detectChunkSize's chunk-sizing (it packs ~60% of context per chunk).
+                options: { num_predict: maxTokens, num_ctx: numCtx ?? 32768 },
             }),
             signal: AbortSignal.timeout(timeoutMs),
         });
@@ -723,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

@@ -303,6 +303,33 @@ export interface HicortexConfig {
      * See #220.
      */
     enableThinking?: boolean;
+    /**
+     * Context window for the ollama FAST tier (importance scoring via `completeFast`).
+     * Default 2048. Scoring prompts are ~850 tokens, so 2048 fits with headroom. The
+     * prior hardcoded 32768 — still the default for the heavy distill/reflect/classify
+     * tiers (which need it for `detectChunkSize`'s chunk-sizing) — made the KV-cache +
+     * prompt-cache accumulate past available RAM on memory-constrained boxes during long
+     * consolidations and swap-thrash the nightly. Applies to scoring only; raise if a
+     * 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.4",
+  "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": {