@gamaze/hicortex 0.16.7 → 0.16.9

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

@@ -366,62 +366,24 @@ async function runNightly(options = {}) {
         // Runs even if capture had transient failures (opens DB directly, independent
         // of the HTTP capture path). Full nightly only — capture-only runs are
         // intended to run more frequently than once daily.
+        let lessonsGenerated; // hoisted for telemetry; undefined when reflection didn't run (skipped) — bucketed apart from a real 0
         if (!dryRun && !captureOnly) {
             if (!llm || !llmConfig) {
                 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,
@@ -429,6 +391,14 @@ async function runNightly(options = {}) {
                 });
                 console.log(`[hicortex] Consolidation ${report.status} in ${report.elapsed_seconds}s` +
                     (report.stages.reflection ? ` (${report.stages.reflection.lessons_generated} lessons)` : ""));
+                // Only set when reflection actually RAN (not skipped). A skipped stage
+                // (e.g. endpoint offline, #232 fail-soft) must NOT collapse to 0 — that
+                // would make "endpoint down" indistinguishable from "prompt too tight"
+                // in the fleet aggregate. Leave undefined so the optional field is
+                // omitted and the aggregate buckets skipped runs separately.
+                const refl = report.stages.reflection;
+                if (refl && !refl.skipped)
+                    lessonsGenerated = refl.lessons_generated;
             }
         }
         // Step 4: Update last-run timestamp.
@@ -473,6 +443,7 @@ async function runNightly(options = {}) {
                 agent: agentType,
                 mem: storage.countMemories(db),
                 lessons: storage.getLessons(db, 365).length,
+                lessonsGenerated,
                 sessions: batches.length,
                 ok: !hadTransientFailure,
                 shown: adoption.shown,

package/dist/prompts.d.ts

@@ -1,6 +1,12 @@
 /**
  * LLM prompt templates for memory consolidation and distillation.
  * Copied EXACTLY from the Python codebase (proven working prompts).
+ *
+ * SHIPPED SOURCE: this file is compiled into dist/ and published to npm + the
+ * public mirror (it is NOT in .publicignore). Any example, name, or detail in
+ * these prompts is therefore public. Use generic, anonymous examples — never
+ * real internal project/tool/host names or real incident specifics. The
+ * infra-name denylist cannot catch conceptual leaks, only known names.
  */
 /**
  * Importance scoring prompt. Takes a {memories_block} with indexed memories.

package/dist/prompts.js

@@ -2,6 +2,12 @@
 /**
  * LLM prompt templates for memory consolidation and distillation.
  * Copied EXACTLY from the Python codebase (proven working prompts).
+ *
+ * SHIPPED SOURCE: this file is compiled into dist/ and published to npm + the
+ * public mirror (it is NOT in .publicignore). Any example, name, or detail in
+ * these prompts is therefore public. Use generic, anonymous examples — never
+ * real internal project/tool/host names or real incident specifics. The
+ * infra-name denylist cannot catch conceptual leaks, only known names.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.importanceScoring = importanceScoring;
@@ -41,6 +47,9 @@ function reflection(memoriesBlock, recentLessons) {
 
 Like human learning: we grow fastest when we reinforce what works AND correct what doesn't. A system that only learns from mistakes becomes overly cautious. A system that only learns from successes never improves. The combination multiplies.
 
+GENERALITY BAR (read carefully — the most important rule):
+Every lesson MUST be a generalizable operating principle that transfers across contexts, agents, and projects. It is NOT: an incident report, a changelog entry, a one-event fact, a tool-specific recipe, or a note about a named entity. If a memory is only interesting as "what happened today", it is an EPISODE — do not emit a lesson for it. Abstract away specific tool names, hostnames, and incident details from the lesson text; state the transferable rule.
+
 Quality over quantity. 1-3 lessons is typical. An empty array [] is the CORRECT response when memories show routine competent work without noteworthy patterns, surprises, or friction. Do not manufacture lessons from nothing.
 
 LESSON TYPES:
@@ -56,15 +65,19 @@ Good reinforce: "Bundling related changes into a single PR with clear narrative
 Good reinforce: "When presenting multi-scenario analysis, show assumptions side-by-side so stakeholders evaluate trade-offs rather than reacting to isolated worst-cases"
 Good correct: "Always verify ALL substitution targets by diffing output — partial fixes cause silent failures"
 Good principle: "Gather evidence from logs before forming hypotheses — evidence-first debugging resolved issues 3x faster today"
+Good principle: "When a long-running background agent survives a system migration as an orphan, explicitly unregister it before declaring the migration clean — orphans cause silent crash-loops"
 Bad lesson: "The deploy script had a bug" (restatement, not actionable)
+Bad (incident note / changelog entry): "The graph resolver was fixed by adding a computed-at marker column" — that is a changelog entry, not a lesson
+Bad (tool-specific decision): "Tool X is banned because it broke Tool Y's settings" — a one-tool decision, not transferable
+Bad (single-event): "The chat client crashed after a system restore because a background agent was left orphaned" — an incident report, not a principle
 
 For each lesson, output a JSON object:
-- "lesson": Concise, actionable rule in imperative voice
+- "lesson": Concise, actionable rule in imperative voice. State the transferable rule — abstract away specific tool names, hostnames, and incident details.
 - "type": "reinforce" | "correct" | "principle"
 - "project": "global" unless genuinely project-specific (project-specific lessons are still valuable)
 - "severity": "critical" | "important" | "minor"
 - "confidence": "high" | "medium" | "low"
-- "source_pattern": What triggered this (1 sentence, no personal data)
+- "source_pattern": What triggered this (1 sentence, no personal data; may name the specific incident/tool here — but the \`lesson\` field itself stays generic)
 
 Severity guide:
 - "critical": Near-misses that could have caused data loss or security breach, even if caught in time. Also: recurring patterns that keep appearing despite prior corrections.
@@ -87,7 +100,7 @@ Focus on:
 
 Privacy: Never include personal data (names, health, finances, credentials) in lesson text. Abstract to the process level.
 
-Skip: isolated trivial actions, already-documented rules. However, if multiple small successes form a consistent pattern of quality, extract that pattern as a reinforcement.
+Skip: isolated trivial actions, already-documented rules, incident notes, changelog entries, and tool-specific recipes. However, if multiple small successes form a consistent pattern of quality, extract that pattern as a reinforcement.
 
 Respond with a JSON array. Empty array [] is a valid response.`;
 }

package/dist/telemetry.d.ts

@@ -13,6 +13,9 @@
  *              client is never miscounted as "cc".
  *   mem      — total memory count
  *   lessons  — total lesson count
+ *   lessonsGenerated — lessons created THIS run (server mode only; the per-run
+ *              delta, distinct from `lessons` which is the corpus total). Lets a
+ *              silent decline in reflection output be seen in the fleet aggregate.
  *   sessions — sessions distilled this run
  *   ok       — nightly succeeded (true/false)
  *   shown    — sum of shown_count (server mode only)
@@ -76,6 +79,12 @@ export interface TelemetryPayload {
     shown?: number;
     uses?: number;
     cold?: number;
+    /**
+     * Lessons generated THIS run (server mode only). The per-run delta —
+     * `lessons` above is the corpus total, which drifts slowly via decay/prune
+     * and can't reveal a sudden drop in reflection output. 0.16.9+.
+     */
+    lessonsGenerated?: number;
 }
 /**
  * Check if telemetry is enabled. Disabled by:

package/dist/telemetry.js

@@ -14,6 +14,9 @@
  *              client is never miscounted as "cc".
  *   mem      — total memory count
  *   lessons  — total lesson count
+ *   lessonsGenerated — lessons created THIS run (server mode only; the per-run
+ *              delta, distinct from `lessons` which is the corpus total). Lets a
+ *              silent decline in reflection output be seen in the fleet aggregate.
  *   sessions — sessions distilled this run
  *   ok       — nightly succeeded (true/false)
  *   shown    — sum of shown_count (server mode only)

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,34 +246,37 @@ 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;
     /**
@@ -334,6 +300,13 @@ export interface HicortexConfig {
      * doubled for margin). Only relevant when `ollamaFlushEvery` > 0.
      */
     ollamaFlushWaitMs?: number;
+    /**
+     * Max lessons injected into an agent's session-start context (default 10).
+     * Lessons are ranked per-session by project/domain affinity + recency +
+     * strength + access, so each session sees its most-relevant slice. Lower =
+     * leaner system prompts.
+     */
+    lessonsLimit?: 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.7",
+  "version": "0.16.9",
   "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": {