@gamaze/hicortex 0.16.6 → 0.16.8

package/dist/mcp-server.js

@@ -76,8 +76,8 @@ const init_js_1 = require("./init.js");
 // ---------------------------------------------------------------------------
 let db = null;
 let llm = null;
-// llmConfig is module-level so the /distill handler can call resolveDistillFallback
-// without having to read config on every request. null when no LLM is configured.
+// llmConfig is module-level so the /distill handler can read numCtx without
+// re-resolving on every request. null when no LLM is configured.
 let llmConfig = null;
 // One-time-per-process deprecation warning for the `?privacy=` query param
 // (0.16.x: the column is vestigial, never filtered). Old clients/plugins still
@@ -94,9 +94,6 @@ function warnDeprecatedPrivacyParamIfPresent(query, route) {
         `privacy is no longer filtered server-side (the column is vestigial). ` +
         `Use a separate Hicortex server for isolation. (This warning fires once per process.)`);
 }
-// distillFallbackMode controls whether a failed remote distill endpoint causes an
-// immediate abort ("strict", default) or a fallback to the base model ("local").
-let distillFallbackMode = "strict";
 let stateDir = "";
 // Resolved contextClients list (spec §2) — the harness names allowed to inject
 // the standing context layer. Echoed by GET /context so each hook self-gates.
@@ -374,7 +371,8 @@ async function startServer(options = {}) {
     // Named backends (claude-cli, ollama) → immediate config; everything else
     // goes through resolveExplicitLlmConfig which requires a user-chosen provider.
     // If nothing is configured: start recall-only with an unmissable warning.
-    const savedConfig = (0, llm_js_1.applyModelsBlock)(readConfigFile(stateDir));
+    // One model serves all phases (#231) — no per-tier overlay here.
+    const savedConfig = readConfigFile(stateDir);
     // 0.16.2 activation gap: self-heal the agentId provenance field for
     // pre-0.16.2 server installs on first boot after upgrade. The server's own
     // nightly captures its sessions to localhost:8787/distill and needs this id;
@@ -402,7 +400,6 @@ async function startServer(options = {}) {
             baseUrl: savedConfig.llmBaseUrl ?? "http://localhost:11434",
             apiKey: "",
             model: savedConfig.llmModel ?? "qwen3.5:4b",
-            reflectModel: savedConfig.reflectModel ?? savedConfig.llmModel ?? "qwen3.5:4b",
             provider: "ollama",
         };
     }
@@ -411,41 +408,15 @@ async function startServer(options = {}) {
             llmBaseUrl: savedConfig?.llmBaseUrl,
             llmApiKey: savedConfig?.llmApiKey,
             llmModel: savedConfig?.llmModel,
-            reflectModel: savedConfig?.reflectModel,
         });
     }
     if (llmConfig) {
-        // Apply optional distill endpoint (e.g. remote Ollama with faster model)
-        if (savedConfig?.distillModel) {
-            llmConfig.distillModel = savedConfig.distillModel;
-        }
-        if (savedConfig?.distillBaseUrl) {
-            llmConfig.distillBaseUrl = savedConfig.distillBaseUrl;
-            llmConfig.distillApiKey = savedConfig.distillApiKey ?? llmConfig.apiKey;
-            llmConfig.distillProvider = savedConfig.distillProvider ?? llmConfig.provider;
-        }
-        // Heavy-phase tuning (#220): maxTokens + enableThinking, validated + copied
-        // via the shared overlay (also applied in resolveSavedLlmConfig for the
-        // nightly's reflect + classify). Wrong-typed values warn + drop.
+        // Tuning (#220: maxTokens + enableThinking + numCtx + flush), validated +
+        // copied via the shared overlay (also applied in resolveSavedLlmConfig for
+        // the nightly). Wrong-typed values warn + drop.
         (0, llm_js_1.applyTierTuningOverlay)(llmConfig, savedConfig);
-        // Apply separate reflect endpoint if configured (e.g. remote Ollama with larger model)
-        if (savedConfig?.reflectBaseUrl) {
-            llmConfig.reflectBaseUrl = savedConfig.reflectBaseUrl;
-            llmConfig.reflectApiKey = savedConfig.reflectApiKey ?? llmConfig.apiKey;
-            llmConfig.reflectProvider = savedConfig.reflectProvider ?? llmConfig.provider;
-        }
-        // distillFallback: "strict" (default) aborts on remote failure so the session
-        // is retried next run. "local" restores 0.9.0 fallback-to-base-model behavior.
-        const df = savedConfig?.distillFallback;
-        distillFallbackMode = df === "local" ? "local" : "strict";
         llm = new llm_js_1.LlmClient(llmConfig);
-        const distillInfo = llmConfig.distillBaseUrl
-            ? `${llmConfig.distillProvider}/${llmConfig.distillModel}@${llmConfig.distillBaseUrl}`
-            : llmConfig.distillModel ? llmConfig.distillModel : "";
-        const reflectInfo = llmConfig.reflectBaseUrl
-            ? `${llmConfig.reflectProvider}/${llmConfig.reflectModel}@${llmConfig.reflectBaseUrl}`
-            : llmConfig.reflectModel;
-        console.log(`[hicortex] LLM fast: ${llmConfig.provider}/${llmConfig.model}${distillInfo ? `, distill: ${distillInfo}` : ""}, reflect: ${reflectInfo}`);
+        console.log(`[hicortex] LLM (one model, all phases): ${llmConfig.provider}/${llmConfig.model}`);
     }
     else {
         llm = null;
@@ -884,23 +855,12 @@ async function startServer(options = {}) {
                 return;
             }
         }
-        // Pre-flight the distill endpoint. In strict mode (default) a failed remote
-        // probe returns "abort" immediately without mutating llmConfig — the nightly
-        // watermark stays put so the session is re-shipped next run. In "local" mode
-        // the config is mutated to fall back to the base model.
-        const cfg = llmConfig;
-        const distillFallbackStatus = await (0, llm_js_1.resolveDistillFallback)(cfg, distillFallbackMode);
-        if (distillFallbackStatus === "abort") {
-            res.status(503).json({ error: "Distill endpoint unavailable — session will be retried next run" });
-            return;
-        }
         // Cache detectChunkSize per endpoint so we probe at most once per server boot.
-        const effectiveProvider = cfg.distillProvider ?? cfg.provider;
-        const effectiveModel = cfg.distillModel ?? cfg.model;
-        const effectiveBaseUrl = cfg.distillBaseUrl ?? cfg.baseUrl;
-        const cacheKey = `${effectiveProvider}/${effectiveModel}@${effectiveBaseUrl}`;
+        // numCtx is passed so chunk size derives from the request's ACTUAL context
+        // window (#231, #228) — the chunker and the request agree by construction.
+        const cacheKey = `${llmConfig.provider}/${llmConfig.model}@${llmConfig.baseUrl}`;
         if (!chunkSizeCache.has(cacheKey)) {
-            chunkSizeCache.set(cacheKey, await (0, distiller_js_1.detectChunkSize)(effectiveProvider, effectiveModel, effectiveBaseUrl));
+            chunkSizeCache.set(cacheKey, await (0, distiller_js_1.detectChunkSize)(llmConfig.provider, llmConfig.model, llmConfig.baseUrl, llmConfig.numCtx));
         }
         const chunkSize = chunkSizeCache.get(cacheKey);
         const date = typeof session_date === "string" && session_date ? session_date : new Date().toISOString().slice(0, 10);

package/dist/nightly-status.js

@@ -18,7 +18,6 @@ const node_os_1 = require("node:os");
 const node_child_process_1 = require("node:child_process");
 const db_js_1 = require("./db.js");
 const state_js_1 = require("./state.js");
-const llm_js_1 = require("./llm.js");
 const HICORTEX_HOME = (0, paths_js_1.hicortexHome)();
 const CONFIG_PATH = (0, node_path_1.join)(HICORTEX_HOME, "config.json");
 async function showNightlyStatus() {
@@ -39,7 +38,7 @@ async function showNightlyStatus() {
     try {
         // No `?? {}` coercion: a null/invalid parse must fall through to the catch
         // below (as it did pre-0.13.1) rather than print a fabricated-healthy status.
-        const config = (0, llm_js_1.applyModelsBlock)(JSON.parse((0, node_fs_1.readFileSync)(CONFIG_PATH, "utf-8")));
+        const config = JSON.parse((0, node_fs_1.readFileSync)(CONFIG_PATH, "utf-8"));
         const backend = config.llmBackend ?? "auto-detect";
         const model = config.llmModel ?? "default";
         const mode = config.mode === "client" ? "client → " + (config.serverUrl ?? "?") : "server (local)";

package/dist/nightly.js

@@ -371,57 +371,18 @@ async function runNightly(options = {}) {
                 console.error("[hicortex] consolidation skipped: no LLM configured — run npx @gamaze/hicortex init");
             }
             else {
-                // Pre-flight health check for the reflect endpoint.
-                // If reflectBaseUrl points to a remote Ollama and it's down (MBP offline),
-                // skip reflection entirely instead of waiting through 3 retries (~3.5 min).
-                // Scoring + linking + decay still run.
-                let skipReflection = false;
-                if (llmConfig.reflectBaseUrl && (llmConfig.reflectProvider ?? llmConfig.provider) === "ollama") {
-                    const reflectModel = llmConfig.reflectModel ?? llmConfig.model;
-                    const health = await (0, llm_js_1.probeOllamaModel)(llmConfig.reflectBaseUrl, reflectModel);
-                    if (!health.ok) {
-                        const reason = health.reason === "unreachable"
-                            ? `reflect endpoint unreachable (${llmConfig.reflectBaseUrl})`
-                            : `reflect model not loaded (${reflectModel} missing on ${llmConfig.reflectBaseUrl})`;
-                        console.warn(`[hicortex] ${reason} — skipping reflection, scoring + linking will still run`);
-                        skipReflection = true;
-                    }
-                }
-                // Content-based domain classification (config-owned `domains`) uses
-                // the classify tier (classifyModel/classifyBaseUrl) when configured,
-                // else the reflect tier. Pre-flight the endpoint classification will
-                // ACTUALLY use (resolveClassifyProbeTarget is the shared source of
-                // truth with `hicortex classify-domains`). If it is down, content
-                // classification is NOT ready this run (strict — skip, don't fall
-                // back). When no `domains` list is configured, this is inert and the
-                // legacy project-grouping path runs.
+                // One model serves all phases (#231) — there is no separate endpoint to
+                // pre-flight. If the model doesn't answer, `complete()` already retries at
+                // 30s/60s/120s (~3.5 min); anything still failing after that is an outage,
+                // not a blip. A failed phase costs latency, not data: capture cursors hold
+                // on failure (dup-over-loss), and consolidation has resumable cursors
+                // (domainCursor, supersessionCursor). The nightly runs 2-4×/day, so the
+                // wait is hours — no polling, no new config. (Issue #231.)
                 const cfgDomains = (0, domain_classify_js_1.parseConfigDomains)(savedConfig);
-                let contentDomainsReady = true;
-                if (cfgDomains) {
-                    const classifyTarget = (0, llm_js_1.resolveClassifyProbeTarget)(llmConfig);
-                    if (classifyTarget?.tier === "reflect") {
-                        // Classification rides the reflect endpoint — reuse the probe above.
-                        contentDomainsReady = !skipReflection;
-                    }
-                    else if (classifyTarget) {
-                        const health = await (0, llm_js_1.probeOllamaModel)(classifyTarget.baseUrl, classifyTarget.model);
-                        if (!health.ok) {
-                            const reason = health.reason === "unreachable"
-                                ? `classify endpoint unreachable (${classifyTarget.baseUrl})`
-                                : `classify model not loaded (${classifyTarget.model} missing on ${classifyTarget.baseUrl})`;
-                            console.warn(`[hicortex] ${reason}`);
-                            contentDomainsReady = false;
-                        }
-                    }
-                    // classifyTarget === null → base endpoint or API provider, no probe.
-                    if (!contentDomainsReady) {
-                        console.warn("[hicortex] content-domain classification skipped — classification endpoint offline (strict)");
-                    }
-                }
                 console.log(`[hicortex] Running consolidation...`);
-                const report = await (0, consolidate_js_1.runConsolidation)(db, llm, embedder_js_1.embed, dryRun, skipReflection, undefined, {
+                const report = await (0, consolidate_js_1.runConsolidation)(db, llm, embedder_js_1.embed, dryRun, false, undefined, {
                     domains: cfgDomains,
-                    contentDomainsReady,
+                    contentDomainsReady: true,
                     weakPrimaryFloor: (0, nofit_js_1.resolveWeakPrimaryFloor)(savedConfig),
                 }, {
                     minSimilarity: savedConfig?.supersessionMinSimilarity,

package/dist/types.d.ts

@@ -154,16 +154,6 @@ export interface ConsolidationReport {
         calls_by_stage: Record<string, number>;
     };
 }
-/**
- * A single per-stage override inside the nested `models` server-config block.
- * Consumed by `applyModelsBlock` (llm.ts), which re-exports this type.
- */
-export interface ModelTierOverride {
-    model?: string;
-    baseUrl?: string;
-    apiKey?: string;
-    provider?: string;
-}
 /** Plugin configuration from openclaw.plugin.json configSchema. */
 export interface HicortexConfig {
     licenseKey?: string;
@@ -186,33 +176,6 @@ export interface HicortexConfig {
     llmApiKey?: string;
     /** @deprecated Use the Hicortex server for distillation and consolidation. */
     llmModel?: string;
-    /** @deprecated Use the Hicortex server for distillation and consolidation. */
-    reflectModel?: string;
-    /**
-     * Optional dedicated model for memory tag classification (server-side
-     * nightly + `hicortex classify-domains`). When unset, classification uses
-     * the reflect tier exactly as before.
-     */
-    classifyModel?: string;
-    /**
-     * Optional dedicated endpoint for classification. When only classifyModel
-     * is set, it runs on the reflect endpoint (else the base endpoint).
-     */
-    classifyBaseUrl?: string;
-    /** Optional API key for the classify endpoint (defaults to the base apiKey). */
-    classifyApiKey?: string;
-    /** Optional provider for the classify endpoint (defaults to the base provider). */
-    classifyProvider?: string;
-    /**
-     * Server config (NOT an OC-plugin key): nested per-stage model overrides.
-     * `{ score|distill|reflect|classify: { model?, baseUrl?, apiKey?, provider? } }`.
-     * Normalized onto the flat `llm*` / `distill*` / `reflect*` / `classify*`
-     * keys at read time (see applyModelsBlock in llm.ts); nested wins, and the
-     * flat keys remain supported at lower precedence. Happy path is a single model via
-     * `llmModel`; use this block only for per-stage routing. `score.provider` is
-     * ignored (base provider comes from llmBackend).
-     */
-    models?: Record<string, ModelTierOverride>;
     /** @deprecated Consolidation is owned by the server nightly. */
     consolidateHour?: number;
     /** @deprecated The OC plugin no longer opens its own database. */
@@ -283,44 +246,51 @@ export interface HicortexConfig {
      */
     preflightRetryGapMs?: number;
     /**
-     * Max output tokens for the LLM phases — distillation, reflection, classification,
-     * and scoring (completeDistill / completeReflect / completeClassify / completeFast).
-     * Default 8192 for the heavy phases, 2048 for scoring (the local fast tier); an
-     * explicit value overrides all of them. A ceiling, not a target: generation stops
-     * at the model's natural end (finish_reason stop), so a higher cap costs no latency
+     * Max output tokens for the ONE LLM model used by all phases — distillation,
+     * reflection, classification, and scoring. Default 8192. An explicit value
+     * overrides the default. A ceiling, not a target: generation stops at the
+     * model's natural end (finish_reason stop), so a higher cap costs no latency
      * when it finishes early. Read in llm.ts; see #220.
      */
     maxTokens?: number;
     /**
      * Toggle the model's internal reasoning ("thinking") stream on the openai-compat
-     * path — applies to the heavy phases (distill / reflect / classify) that share an
-     * OpenAI-compatible endpoint (e.g. a reasoning model served via a local gateway).
-     * Default false. A thinking model with thinking ON can burn the entire token
-     * budget on an unclosed <think> block and emit nothing (probed 2026-08-04). When
-     * set (true or false), completeOpenAiCompat sends
-     * chat_template_kwargs:{enable_thinking}. Threaded structurally from each heavy
-     * phase, so scoring (ollama) never sends it. No effect on the anthropic path.
-     * See #220.
+     * path — applies to ALL phases (distill / reflect / classify / scoring) since one
+     * model serves all of them. Default false. A thinking model with thinking ON can
+     * burn the entire token budget on an unclosed <think> block and emit nothing
+     * (probed 2026-08-04). When set (true or false), completeOpenAiCompat sends
+     * chat_template_kwargs:{enable_thinking}. LOCAL-ENDPOINT ONLY: this is meaningful
+     * only for a chat-template-aware server (ollama, mlx-lm). If the one model is a
+     * cloud OpenAI-compatible endpoint (OpenAI / OpenRouter / Groq / z.ai), LEAVE THIS
+     * UNSET — the non-standard chat_template_kwargs field rides every call and can 400
+     * the whole pipeline (provider cannot distinguish MLX-gateway-as-openai from real
+     * cloud openai, so the gate must be operator-set, not detected). No effect on the
+     * anthropic or claude-cli paths. See #220, #231.
      */
     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.
+     * Context window for ollama (the one model, all phases). Default 8192 — the point
+     * where context stops being the binding constraint for a sub-8B model on ollama
+     * (above it the SMALL_MODEL_MAX_CHUNK_CHARS speed cap binds instead, so extra
+     * context buys nothing). Also drives `detectChunkSize`'s chunk sizing
+     * (chunkChars ≤ numCtx × 0.6 × 4 chars), so numCtx is the single dial and the
+     * chunker/request agreement is enforced by construction (#228). For an ≥8B model
+     * on ollama the speed cap is 60,000 chars, needing numCtx ≈ 25000 to reach — raise
+     * it if running 8B+ locally. No effect for non-ollama providers.
      */
     numCtx?: number;
     /**
-     * Flush ollama's accumulated memory every N ollama calls — workaround for
+     * Flush ollama's accumulated memory every N scoring 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.
+     * during long consolidations. Default 0 (off). When >0, every Nth scoring call
+     * (`completeFast`) 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. Scoped to the fast tier (scoring) only. Note:
+     * N counts **logical** scoring calls, not raw HTTP requests — `complete()`
+     * retries up to 4× on timeout, so under retry pressure the actual accumulation
+     * may be up to 4×N calls' worth. In practice the flush prevents the thrash that
+     * causes retries, keeping the count accurate.
      */
     ollamaFlushEvery?: number;
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gamaze/hicortex",
-  "version": "0.16.6",
+  "version": "0.16.8",
   "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": {