@gamaze/hicortex 0.16.6 → 0.16.8

package/dist/llm.js

@@ -2,6 +2,9 @@
 /**
  * Multi-provider LLM client for consolidation and distillation.
  *
+ * ONE model serves all phases (distill, reflect, classify, scoring) — #231.
+ * The 0.16.x per-tier split (distill, reflect, classify + base) is removed.
+ *
  * Resolution (resolveExplicitLlmConfig):
  *   1. Explicit config-file overrides (llmBaseUrl + llmApiKey + llmModel)
  *   2. Hicortex-specific env vars (HICORTEX_LLM_BASE_URL + HICORTEX_LLM_API_KEY + HICORTEX_LLM_MODEL)
@@ -17,15 +20,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LlmClient = exports.RateLimitError = exports.resolveLlmConfigForCC = void 0;
 exports.resolveExplicitLlmConfig = resolveExplicitLlmConfig;
-exports.applyModelsBlock = applyModelsBlock;
 exports.applyTierTuningOverlay = applyTierTuningOverlay;
 exports.resolveSavedLlmConfig = resolveSavedLlmConfig;
-exports.resolveClassifyProbeTarget = resolveClassifyProbeTarget;
 exports.findClaudeBinary = findClaudeBinary;
 exports.claudeCliConfig = claudeCliConfig;
 exports.probeOllama = probeOllama;
-exports.probeOllamaModel = probeOllamaModel;
-exports.resolveDistillFallback = resolveDistillFallback;
 const config_read_js_1 = require("./config-read.js");
 /**
  * Resolve LLM configuration from explicit config-file overrides or
@@ -47,7 +46,6 @@ function resolveExplicitLlmConfig(overrides) {
             baseUrl: overrides.llmBaseUrl,
             apiKey: overrides.llmApiKey,
             model: overrides.llmModel ?? "claude-haiku-4-5-20251001",
-            reflectModel: overrides.reflectModel ?? overrides.llmModel ?? "claude-sonnet-4-6",
             provider,
         };
     }
@@ -61,7 +59,6 @@ function resolveExplicitLlmConfig(overrides) {
             baseUrl: hcBaseUrl,
             apiKey: hcApiKey,
             model: hcModel ?? "claude-haiku-4-5-20251001",
-            reflectModel: process.env.HICORTEX_REFLECT_MODEL ?? hcModel ?? "claude-sonnet-4-6",
             provider,
         };
     }
@@ -74,129 +71,19 @@ function resolveExplicitLlmConfig(overrides) {
  */
 exports.resolveLlmConfigForCC = resolveExplicitLlmConfig;
 /**
- * Map from a `models.<tier>` name to the flat config keys it feeds. The base
- * tier is `score` — score IS the base model today (completeFast reads
- * config.model), so it lands on the llm* keys and its `provider` is ignored
- * (the base provider comes from llmBackend / detectProvider, not config).
- * Tiers with a `provider` key (distill/reflect/classify) apply their apiKey +
- * provider through a baseUrl-gated overlay downstream; `score` (no provider
- * key) rides the base resolution.
- */
-const MODELS_TIER_KEYS = {
-    score: { model: "llmModel", baseUrl: "llmBaseUrl", apiKey: "llmApiKey" },
-    distill: { model: "distillModel", baseUrl: "distillBaseUrl", apiKey: "distillApiKey", provider: "distillProvider" },
-    reflect: { model: "reflectModel", baseUrl: "reflectBaseUrl", apiKey: "reflectApiKey", provider: "reflectProvider" },
-    classify: { model: "classifyModel", baseUrl: "classifyBaseUrl", apiKey: "classifyApiKey", provider: "classifyProvider" },
-};
-/**
- * Normalize a nested `models: { <tier>: {model,baseUrl,apiKey,provider} }` block
- * onto the flat `llm*` / `distill*` / `reflect*` / `classify*` keys the resolver
- * already consumes. Nested overrides WIN over any flat key of the same name; every
- * non-mapped key (llmBackend, licenseKey, distillFallback, contextClients, …)
- * is preserved via spread. Pure: returns the SAME reference when there is no
- * `models` key, so this is a provable no-op for every existing install.
+ * Validate + copy the tuning keys (#220: maxTokens + enableThinking + numCtx +
+ * ollama flush) from the saved disk config onto a runtime LlmConfig. Called by
+ * BOTH LlmConfig construction sites — the daemon in mcp-server.ts (runs
+ * distill) AND resolveSavedLlmConfig below (the nightly runs reflect +
+ * classify) — so every process honors the keys, and a future site calling this
+ * inherits them by construction.
  *
- * Robust to a malformed config.json: a config that parses to a scalar, array,
- * or null is returned untouched (matching the pre-0.13.1 optional-chaining
- * tolerance — this function must never throw at server/nightly boot).
- *
- * Fail-explicit (warn + skip, never throw): an invalid `models` value, an
- * unknown tier name, a non-object tier value, a non-string field value, a tier
- * apiKey/provider set without a baseUrl (they are baseUrl-gated downstream), and
- * a dead score apiKey/provider under an ollama base.
- */
-function applyModelsBlock(saved) {
-    // Guard the container itself first — `"models" in saved` throws a TypeError on
-    // a truthy non-object (config.json = `true`/`5`/`"x"`); such configs must pass
-    // through so the boot path degrades to recall-only exactly as before.
-    if (typeof saved !== "object" || saved === null || Array.isArray(saved))
-        return saved;
-    if (!("models" in saved))
-        return saved;
-    const models = saved.models;
-    if (typeof models !== "object" || models === null || Array.isArray(models)) {
-        console.warn(`[hicortex] Ignoring invalid "models" config: expected an object of per-tier overrides, got ${Array.isArray(models) ? "array" : models === null ? "null" : typeof models}`);
-        return saved;
-    }
-    const ollamaBase = saved.llmBackend === "ollama";
-    const mapped = {};
-    for (const [tier, value] of Object.entries(models)) {
-        const keys = MODELS_TIER_KEYS[tier];
-        if (!keys) {
-            console.warn(`[hicortex] Ignoring unknown "models" tier "${tier}" (expected: score, distill, reflect, classify)`);
-            continue;
-        }
-        if (typeof value !== "object" || value === null || Array.isArray(value)) {
-            console.warn(`[hicortex] Ignoring invalid "models.${tier}" override: expected an object with model/baseUrl/apiKey/provider`);
-            continue;
-        }
-        const o = value;
-        // Per-field string validation: a non-string value would map verbatim and
-        // fail opaquely downstream (e.g. baseUrl: 11434), so drop it with a warning.
-        const strField = (name) => {
-            const v = o[name];
-            if (v === undefined)
-                return undefined;
-            if (typeof v !== "string") {
-                console.warn(`[hicortex] Ignoring non-string "models.${tier}.${name}" (expected a string)`);
-                return undefined;
-            }
-            return v;
-        };
-        const model = strField("model");
-        const baseUrl = strField("baseUrl");
-        const apiKey = strField("apiKey");
-        const provider = strField("provider");
-        if (model !== undefined)
-            mapped[keys.model] = model;
-        if (baseUrl !== undefined)
-            mapped[keys.baseUrl] = baseUrl;
-        if (keys.provider) {
-            // Overlay tier (distill/reflect/classify): the downstream overlay only
-            // consumes apiKey/provider when the tier ALSO sets its own baseUrl.
-            // Without one, they would silently bill to the base key — so warn + drop.
-            if ((apiKey !== undefined || provider !== undefined) && baseUrl === undefined) {
-                console.warn(`[hicortex] Ignoring "models.${tier}" apiKey/provider without a baseUrl: they only take effect when the tier sets its own baseUrl`);
-            }
-            else {
-                if (apiKey !== undefined)
-                    mapped[keys.apiKey] = apiKey;
-                if (provider !== undefined)
-                    mapped[keys.provider] = provider;
-            }
-        }
-        else {
-            // score = base tier: no separate provider key, and apiKey rides llmApiKey.
-            if (provider !== undefined) {
-                console.warn(`[hicortex] Ignoring "models.score.provider": the base provider comes from llmBackend (or is auto-detected from the endpoint)`);
-            }
-            if (apiKey !== undefined) {
-                if (ollamaBase) {
-                    // The ollama base path hardcodes an empty api key and never reads
-                    // llmApiKey, so score.apiKey is dead there.
-                    console.warn(`[hicortex] Ignoring "models.score.apiKey": the base ollama path sends no api key`);
-                }
-                else {
-                    mapped[keys.apiKey] = apiKey;
-                }
-            }
-        }
-    }
-    return { ...saved, ...mapped };
-}
-/**
- * Validate + copy the heavy-phase tuning keys (#220: maxTokens + enableThinking)
- * from the saved disk config onto a runtime LlmConfig. Called by BOTH LlmConfig
- * construction sites — the daemon in mcp-server.ts (runs distill) AND
- * resolveSavedLlmConfig below (the nightly runs reflect + classify) — so every
- * process that runs a heavy phase honors the keys, and a future site calling
- * this inherits them by construction.
- *
- * Both keys are optional; absent = call-site defaults (8192 / thinking kwarg
- * omitted). Wrong-typed values warn and are dropped (readPositiveConfig /
- * readStrictBoolean) — notably a JSON slip `"enableThinking": "false"` (string)
- * is rejected rather than coerced to truthy thinking-on, which would silently
- * invert the fix this key exists to apply.
+ * All keys are optional; absent = call-site defaults (maxTokens 8192, numCtx
+ * 8192, thinking kwarg omitted, flush off). Wrong-typed values warn and are
+ * dropped (readPositiveConfig / readStrictBoolean / readNonNegativeConfig) —
+ * notably a JSON slip `"enableThinking": "false"` (string) is rejected rather
+ * than coerced to truthy thinking-on, which would silently invert the fix this
+ * key exists to apply.
  */
 function applyTierTuningOverlay(llmConfig, savedConfig) {
     if (!savedConfig)
@@ -209,10 +96,10 @@ function applyTierTuningOverlay(llmConfig, savedConfig) {
         llmConfig.enableThinking = thinking;
     }
     if (savedConfig.numCtx !== undefined) {
-        llmConfig.numCtx = (0, config_read_js_1.readPositiveConfig)(savedConfig, "numCtx", 2048);
+        llmConfig.numCtx = (0, config_read_js_1.readPositiveConfig)(savedConfig, "numCtx", 8192);
     }
     if (savedConfig.ollamaFlushEvery !== undefined) {
-        llmConfig.ollamaFlushEvery = (0, config_read_js_1.readPositiveConfig)(savedConfig, "ollamaFlushEvery", 0);
+        llmConfig.ollamaFlushEvery = (0, config_read_js_1.readNonNegativeConfig)(savedConfig, "ollamaFlushEvery", 0);
     }
     if (savedConfig.ollamaFlushWaitMs !== undefined) {
         llmConfig.ollamaFlushWaitMs = (0, config_read_js_1.readPositiveConfig)(savedConfig, "ollamaFlushWaitMs", 180000);
@@ -223,9 +110,8 @@ function applyTierTuningOverlay(llmConfig, savedConfig) {
  *
  * This is the SINGLE config path used by pipeline runs (nightly consolidation
  * and `hicortex relink`): named backends (claude-cli, ollama) first, then the
- * explicit-config/env fallthrough via resolveExplicitLlmConfig, then the
- * reflect endpoint overlay. Extracted verbatim from nightly.ts — behavior
- * is identical to the pre-0.11 inline block.
+ * explicit-config/env fallthrough via resolveExplicitLlmConfig. One model
+ * serves all phases (#231) — there is no per-tier overlay here.
  *
  * Returns `reason: "claude_binary_missing"` when claude-cli is configured but
  * the binary can't be found, so callers can log a context-specific message.
@@ -235,7 +121,6 @@ function applyTierTuningOverlay(llmConfig, savedConfig) {
  * deterministically in tests without depending on the host filesystem.
  */
 function resolveSavedLlmConfig(savedConfig, findBinary = findClaudeBinary) {
-    savedConfig = applyModelsBlock(savedConfig);
     let llmConfig = null;
     if (savedConfig?.llmBackend === "claude-cli") {
         const claudePath = findBinary();
@@ -251,7 +136,6 @@ function resolveSavedLlmConfig(savedConfig, findBinary = findClaudeBinary) {
             baseUrl: savedConfig.llmBaseUrl ?? "http://localhost:11434",
             apiKey: "",
             model: savedConfig.llmModel ?? "qwen3.5:4b",
-            reflectModel: savedConfig.reflectModel ?? savedConfig.llmModel ?? "qwen3.5:4b",
             provider: "ollama",
         };
     }
@@ -260,71 +144,15 @@ function resolveSavedLlmConfig(savedConfig, findBinary = findClaudeBinary) {
             llmBaseUrl: savedConfig?.llmBaseUrl,
             llmApiKey: savedConfig?.llmApiKey,
             llmModel: savedConfig?.llmModel,
-            reflectModel: savedConfig?.reflectModel,
         });
     }
-    if (llmConfig && savedConfig?.reflectBaseUrl) {
-        llmConfig.reflectBaseUrl = savedConfig.reflectBaseUrl;
-        llmConfig.reflectApiKey = savedConfig.reflectApiKey ?? llmConfig.apiKey;
-        llmConfig.reflectProvider = savedConfig.reflectProvider ?? llmConfig.provider;
-    }
-    // Heavy-phase tuning (#220: maxTokens + enableThinking). The nightly runs
-    // reflect + classify (consolidation), the daemon runs distill — both need the
-    // keys, so the overlay is applied at both construction sites.
+    // Tuning overlay (#220: maxTokens + enableThinking + numCtx + flush). Applied
+    // at both construction sites (daemon + nightly) so every phase honors the keys.
     if (llmConfig) {
         applyTierTuningOverlay(llmConfig, savedConfig);
     }
-    // Optional classify tier (memory tag classification). Same overlay pattern
-    // as distillModel/distillBaseUrl: when absent, completeClassify falls back
-    // to the reflect tier — zero behavior change for existing installs.
-    if (llmConfig && savedConfig?.classifyModel) {
-        llmConfig.classifyModel = savedConfig.classifyModel;
-    }
-    if (llmConfig && savedConfig?.classifyBaseUrl) {
-        llmConfig.classifyBaseUrl = savedConfig.classifyBaseUrl;
-        llmConfig.classifyApiKey = savedConfig.classifyApiKey ?? llmConfig.apiKey;
-        llmConfig.classifyProvider = savedConfig.classifyProvider ?? llmConfig.provider;
-    }
     return { config: llmConfig };
 }
-/**
- * Endpoint + model that memory tag classification will ACTUALLY use, for
- * pre-flight probing. Pure function — the single source of truth shared by
- * the nightly's contentDomainsReady gate and `hicortex classify-domains`.
- *
- * Mirrors LlmClient.completeClassify's routing:
- *   - classify tier configured (classifyModel and/or classifyBaseUrl) →
- *     classifyBaseUrl ?? reflectBaseUrl, classifyModel ?? reflectModel
- *   - classify tier absent → the reflect tier (reflectBaseUrl/reflectModel),
- *     exactly what completeReflect uses
- *
- * Returns null when no probe applies: only a SEPARATE Ollama endpoint can go
- * unreachable mid-run (API providers are cloud-reachable; the base endpoint
- * is not pre-flighted anywhere, matching distill/reflect behavior).
- *
- * `tier` tells callers which configuration produced the target — "reflect"
- * means the classification probe is identical to the reflect-stage probe and
- * its result can be reused.
- */
-function resolveClassifyProbeTarget(config) {
-    const classifyConfigured = Boolean(config.classifyModel || config.classifyBaseUrl);
-    if (classifyConfigured) {
-        const baseUrl = config.classifyBaseUrl ?? config.reflectBaseUrl;
-        const model = config.classifyModel ?? config.reflectModel;
-        const provider = config.classifyBaseUrl
-            ? (config.classifyProvider ?? config.provider)
-            : (config.reflectProvider ?? config.provider); // riding the reflect endpoint
-        if (baseUrl && provider === "ollama") {
-            return { tier: "classify", baseUrl, model };
-        }
-        return null; // base endpoint or API provider — no probe
-    }
-    // Classify tier absent — classification delegates to completeReflect.
-    if (config.reflectBaseUrl && (config.reflectProvider ?? config.provider) === "ollama") {
-        return { tier: "reflect", baseUrl: config.reflectBaseUrl, model: config.reflectModel ?? config.model };
-    }
-    return null;
-}
 function detectProvider(url) {
     const u = url.toLowerCase();
     if (u.includes("ollama") || u.includes(":11434"))
@@ -372,7 +200,6 @@ function claudeCliConfig(claudePath) {
         baseUrl: claudePath,
         apiKey: "",
         model: "haiku",
-        reflectModel: "haiku",
         provider: "claude-cli",
     };
 }
@@ -404,96 +231,6 @@ async function probeOllama(baseUrl = "http://localhost:11434") {
         return null;
     }
 }
-/**
- * Pre-flight health check for a specific Ollama endpoint + model.
- * Returns { ok, reason } so callers can log a clear abort message.
- *
- *   - `ok: true` — endpoint reachable AND the requested model appears in
- *     `/api/tags`. Safe to proceed with a batch distillation run.
- *   - `ok: false, reason: "unreachable"` — network failure or non-2xx.
- *   - `ok: false, reason: "model_missing"` — endpoint is up but the
- *     model isn't listed (the exact case that caused data loss when
- *     a remote Ollama box didn't have the distill model loaded).
- *
- * Matches on exact name OR name prefix ("qwen3.5:35b" matches "qwen3.5:35b-a3b").
- */
-async function probeOllamaModel(baseUrl, modelName) {
-    try {
-        const resp = await fetch(`${baseUrl.replace(/\/$/, "")}/api/tags`, {
-            signal: AbortSignal.timeout(5000),
-        });
-        if (!resp.ok)
-            return { ok: false, reason: "unreachable" };
-        const data = (await resp.json());
-        const models = data.models ?? [];
-        const found = models.some((m) => m.name === modelName || m.name.startsWith(modelName + ":"));
-        return found ? { ok: true } : { ok: false, reason: "model_missing" };
-    }
-    catch {
-        return { ok: false, reason: "unreachable" };
-    }
-}
-/**
- * Resolve the distillation endpoint before a /distill request.
- *
- * @param config  LlmConfig (mutated in "local" mode when fallback is used)
- * @param mode
- *   "strict" (default) — when a separate distillBaseUrl is configured and its
- *     Ollama probe fails, return "abort" immediately WITHOUT mutating config.
- *     The session is not distilled now; the nightly watermark is not advanced,
- *     so the session is re-shipped on the next run (harness stores retain raw
- *     for 30–90 days — the retry IS the queue). Prefer this to producing
- *     low-quality memories from a weak fallback model.
- *   "local" — legacy 0.9.0 behaviour: fall back to the base endpoint (local
- *     Ollama or API provider) when the remote is down. Mutates config IN PLACE
- *     to repoint distill* at the fallback.
- *
- * Returns:
- *   "ok"       — remote distill endpoint healthy, or no separate endpoint set
- *   "fellback" — ("local" mode only) remote down; distill redirected to base
- *   "abort"    — remote down and fallback not allowed (strict) or both down (local)
- */
-async function resolveDistillFallback(config, mode = "strict") {
-    const distillProvider = config.distillProvider ?? config.provider;
-    // Only a remote Ollama distill endpoint can go unreachable mid-run; API
-    // providers are cloud-reachable and need no fallback.
-    if (!config.distillBaseUrl || distillProvider !== "ollama")
-        return "ok";
-    const distillModel = config.distillModel ?? config.model;
-    const remote = await probeOllamaModel(config.distillBaseUrl, distillModel);
-    if (remote.ok)
-        return "ok";
-    const reason = remote.reason === "unreachable"
-        ? `remote distill endpoint unreachable (${config.distillBaseUrl})`
-        : `remote distill model not loaded (${distillModel} on ${config.distillBaseUrl})`;
-    if (mode === "strict") {
-        // Do not mutate config. Log once and let the caller return 503 so the
-        // nightly watermark stays put and the session is retried next run.
-        console.error(`[hicortex] ABORT: ${reason} — session will be retried next run`);
-        return "abort";
-    }
-    // "local" mode: fall back to the base endpoint.
-    // If the base is Ollama, verify it is actually up before committing;
-    // if the base is an API provider, it is cloud-reachable.
-    if (config.provider === "ollama") {
-        const local = await probeOllamaModel(config.baseUrl, config.model);
-        if (!local.ok) {
-            console.error(`[hicortex] ABORT: ${reason}, and local fallback (${config.model} on ${config.baseUrl}) also unavailable — retry next run`);
-            return "abort";
-        }
-        config.distillBaseUrl = config.baseUrl;
-    }
-    else {
-        // Base is an API provider — route distill through it (no separate baseUrl).
-        config.distillBaseUrl = undefined;
-    }
-    config.distillModel = config.model;
-    config.distillProvider = config.provider;
-    config.distillApiKey = config.apiKey;
-    console.warn(`[hicortex] ${reason} — falling back to base endpoint for distillation ` +
-        `(${config.provider}/${config.model}). Lower quality, but capture continues.`);
-    return "fellback";
-}
 // ---------------------------------------------------------------------------
 // LLM Client class
 // ---------------------------------------------------------------------------
@@ -508,12 +245,11 @@ class RateLimitError extends Error {
     }
 }
 exports.RateLimitError = RateLimitError;
-// Rate-limit backoff is shared across all LlmClient instances that target the
-// same endpoint, keyed by provider@baseUrl. completeWithOverride() spins up a
-// throwaway client per call for the distill/reflect/classify override tiers;
-// with per-instance state each throwaway started un-rate-limited and re-hit a
-// 429'd provider immediately, defeating the backoff on exactly the configs
-// (e.g. z.ai via distillBaseUrl/reflectBaseUrl) that route through those tiers.
+// Rate-limit backoff is keyed by provider@baseUrl at module scope so it is
+// shared across any LlmClient instances that target the same endpoint (e.g. a
+// daemon client + a future constructed client). One model serves all phases
+// (#231), so in practice there is a single client per process today; the
+// module-level map keeps the state shared correctly if that ever changes.
 const rateLimitedUntilByEndpoint = new Map();
 class LlmClient {
     config;
@@ -545,88 +281,50 @@ class LlmClient {
         throw new RateLimitError(retryMs);
     }
     /**
-     * Fast-tier completion (importance scoring, simple tasks).
+     * Fast-tier completion (importance scoring, simple tasks). One model serves
+     * all phases (#231); numCtx + enableThinking are read from config directly
+     * inside completeOnce's per-provider dispatch, not threaded here. The periodic
+     * ollama flush stays (provider-gated) — it is a scoring-call-count cadence and
+     * scoring is the highest-frequency call, so this is where the flush belongs.
      */
     async completeFast(prompt, maxTokens) {
-        const tokens = maxTokens ?? this.config.maxTokens ?? 2048;
-        // 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);
+        const tokens = maxTokens ?? this.config.maxTokens ?? 8192;
+        const result = await this.complete(this.config.model, prompt, tokens, 600_000);
+        const flushEvery = this.config.ollamaFlushEvery ?? 0;
+        if (this.config.provider === "ollama" && flushEvery > 0) {
+            this.ollamaCallCount++;
+            if (this.ollamaCallCount >= flushEvery) {
+                await this.flushOllama(this.config.model);
+                this.ollamaCallCount = 0;
+            }
+        }
+        return result;
     }
     /**
-     * Reflect-tier completion (nightly reflection, needs reasoning).
-     * Routes to reflectBaseUrl/reflectProvider if configured (e.g. remote Ollama with larger model).
+     * Reflect-tier completion (nightly reflection). One model serves all phases
+     * (#231) — this is a thin wrapper kept for call-site readability.
      */
     async completeReflect(prompt, maxTokens) {
         const tokens = maxTokens ?? this.config.maxTokens ?? 8192;
-        const thinking = this.config.enableThinking;
-        if (this.config.reflectBaseUrl) {
-            return this.completeWithOverride(this.config.reflectBaseUrl, this.config.reflectApiKey ?? this.config.apiKey, this.config.reflectProvider ?? this.config.provider, this.config.reflectModel, prompt, tokens, 900_000, thinking);
-        }
-        return this.complete(this.config.reflectModel, prompt, tokens, 900_000, thinking);
+        return this.complete(this.config.model, prompt, tokens, 900_000);
     }
     /**
-     * Distillation-tier completion (session knowledge extraction).
-     * Routes to distillBaseUrl/distillProvider if configured (e.g. remote Ollama with faster model).
+     * Distillation-tier completion (session knowledge extraction). One model
+     * serves all phases (#231) — thin wrapper kept for call-site readability.
      */
     async completeDistill(prompt, maxTokens) {
         const tokens = maxTokens ?? this.config.maxTokens ?? 8192;
-        // enableThinking is threaded explicitly (not read inside the shared
-        // completeOpenAiCompat) so the chat_template_kwargs kwarg is scoped to the
-        // heavy phases — distill/reflect/classify — and never reaches scoring. See #220.
-        const thinking = this.config.enableThinking;
-        if (this.config.distillBaseUrl) {
-            return this.completeWithOverride(this.config.distillBaseUrl, this.config.distillApiKey ?? this.config.apiKey, this.config.distillProvider ?? this.config.provider, this.config.distillModel ?? this.config.model, prompt, tokens, 900_000, thinking);
-        }
-        return this.complete(this.config.distillModel ?? this.config.model, prompt, tokens, 900_000, thinking);
+        return this.complete(this.config.model, prompt, tokens, 900_000);
     }
     /**
-     * Classification-tier completion (memory tag classification).
-     *
-     * Routing (same "optional dedicated model+baseUrl with fallback" pattern as
-     * completeDistill; Ollama calls inherit think:false via completeOllama):
-     *   - Neither classifyModel nor classifyBaseUrl set → delegate to
-     *     completeReflect (exactly the pre-classify-tier behavior).
-     *   - classifyBaseUrl set → that endpoint, model classifyModel ?? reflectModel.
-     *   - Only classifyModel set → the classify model on the reflect endpoint
-     *     when one is configured, else on the base endpoint.
+     * Classification-tier completion (memory tag classification). One model
+     * serves all phases (#231) — thin wrapper kept for call-site readability.
      */
     async completeClassify(prompt, maxTokens) {
         const tokens = maxTokens ?? this.config.maxTokens ?? 8192;
-        const thinking = this.config.enableThinking;
-        if (!this.config.classifyModel && !this.config.classifyBaseUrl) {
-            return this.completeReflect(prompt, tokens);
-        }
-        const model = this.config.classifyModel ?? this.config.reflectModel;
-        if (this.config.classifyBaseUrl) {
-            return this.completeWithOverride(this.config.classifyBaseUrl, this.config.classifyApiKey ?? this.config.apiKey, this.config.classifyProvider ?? this.config.provider, model, prompt, tokens, 900_000, thinking);
-        }
-        if (this.config.reflectBaseUrl) {
-            return this.completeWithOverride(this.config.reflectBaseUrl, this.config.reflectApiKey ?? this.config.apiKey, this.config.reflectProvider ?? this.config.provider, model, prompt, tokens, 900_000, thinking);
-        }
-        return this.complete(model, prompt, tokens, 900_000, thinking);
+        return this.complete(this.config.model, prompt, tokens, 900_000);
     }
-    /**
-     * Complete with overridden baseUrl/apiKey/provider (used for reflect tier with separate endpoint).
-     * Creates a temporary LlmClient to avoid mutating shared config under concurrent calls.
-     */
-    async completeWithOverride(baseUrl, apiKey, provider, model, prompt, maxTokens, timeoutMs, thinking) {
-        const tempClient = new LlmClient({
-            ...this.config,
-            baseUrl,
-            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, numCtx) {
+    async complete(model, prompt, maxTokens, timeoutMs) {
         if (this.isRateLimited) {
             throw new RateLimitError(this.rateLimitedUntil - Date.now());
         }
@@ -634,7 +332,7 @@ class LlmClient {
         let lastErr;
         for (let attempt = 0; attempt <= retryDelays.length; attempt++) {
             try {
-                return await this.completeOnce(model, prompt, maxTokens, timeoutMs, thinking, numCtx);
+                return await this.completeOnce(model, prompt, maxTokens, timeoutMs);
             }
             catch (err) {
                 lastErr = err instanceof Error ? err : new Error(String(err));
@@ -651,20 +349,18 @@ class LlmClient {
         }
         throw lastErr;
     }
-    async completeOnce(model, prompt, maxTokens, timeoutMs, thinking, numCtx) {
+    async completeOnce(model, prompt, maxTokens, timeoutMs) {
         if (this.config.provider === "claude-cli") {
             return this.completeClaude(model, prompt, timeoutMs);
         }
         if (this.config.provider === "ollama") {
-            return this.completeOllama(model, prompt, maxTokens, timeoutMs, numCtx);
+            return this.completeOllama(model, prompt, maxTokens, timeoutMs);
         }
         if (this.config.provider === "anthropic") {
             return this.completeAnthropic(model, prompt, maxTokens, timeoutMs);
         }
-        // thinking is threaded from each heavy phase (distill/reflect/classify), so
-        // the kwarg is emitted for those tiers on the openai-compat path; completeFast
-        // (scoring) never passes it (PR #227 review F1).
-        return this.completeOpenAiCompat(model, prompt, maxTokens, timeoutMs, thinking);
+        // enableThinking is read from config here (one value, all phases — #231).
+        return this.completeOpenAiCompat(model, prompt, maxTokens, timeoutMs);
     }
     /**
      * Claude CLI: shell out to `claude -p` for subscription users.
@@ -691,8 +387,9 @@ class LlmClient {
     }
     /**
      * Ollama: use /api/generate with think:false (important for qwen3.5 models).
+     * num_ctx is read from config (one value, all phases — #231; default 8192).
      */
-    async completeOllama(model, prompt, maxTokens, timeoutMs, numCtx) {
+    async completeOllama(model, prompt, maxTokens, timeoutMs) {
         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)
@@ -704,14 +401,11 @@ class LlmClient {
                 prompt,
                 stream: true,
                 think: false,
-                // 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 },
+                // num_ctx: one value for all phases (#231), 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). Also
+                // drives detectChunkSize, so the chunker and the request agree by construction.
+                options: { num_predict: maxTokens, num_ctx: this.config.numCtx ?? 8192 },
             }),
             signal: AbortSignal.timeout(timeoutMs),
         });
@@ -746,20 +440,6 @@ 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();
     }
     /**
@@ -767,10 +447,14 @@ class LlmClient {
      * 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.
+     * 180 s). Logs the flush so the wait is distinguishable from a hang. If the
+     * unload request fails (ollama down), the wait is skipped — no dead time for a
+     * release that can't have happened. See #229 review.
      */
     async flushOllama(model) {
         const url = `${this.config.baseUrl.replace(/\/$/, "")}/api/generate`;
+        const waitMs = this.config.ollamaFlushWaitMs ?? 180_000;
+        console.log(`[hicortex] ollama flush: unloading ${model} after ${this.ollamaCallCount} scoring calls, waiting ${waitMs / 1000}s for memory release…`);
         try {
             await fetch(url, {
                 method: "POST",
@@ -778,10 +462,12 @@ class LlmClient {
                 body: JSON.stringify({ model, keep_alive: 0 }),
                 signal: AbortSignal.timeout(60_000),
             });
+            await new Promise((r) => setTimeout(r, waitMs));
+            console.log(`[hicortex] ollama flush: complete`);
+        }
+        catch {
+            console.warn(`[hicortex] ollama flush: unload request failed (ollama unreachable?) — skipping wait`);
         }
-        catch { /* best-effort flush */ }
-        const waitMs = this.config.ollamaFlushWaitMs ?? 180_000;
-        await new Promise((r) => setTimeout(r, waitMs));
     }
     /**
      * Anthropic Messages API (/v1/messages).
@@ -817,8 +503,9 @@ class LlmClient {
     }
     /**
      * OpenAI-compatible /v1/chat/completions (works for OpenAI, OpenRouter, etc).
+     * enableThinking is read from config here (one value, all phases — #231).
      */
-    async completeOpenAiCompat(model, prompt, maxTokens, timeoutMs, thinking) {
+    async completeOpenAiCompat(model, prompt, maxTokens, timeoutMs) {
         const baseUrl = this.config.baseUrl.replace(/\/$/, "");
         // Some providers include the API version in the base URL already
         const hasVersion = /\/v\d+\/?$/.test(baseUrl);
@@ -832,11 +519,13 @@ class LlmClient {
             headers["Authorization"] = `Bearer ${this.config.apiKey}`;
         }
         // Qwen3 thinking mode: when on, the model can burn the whole token budget on
-        // an unclosed <think> block and emit nothing (probed 2026-08-04). `thinking`
-        // is threaded here ONLY from completeDistill, so the kwarg is emitted solely
-        // for the distill tier — reflect/classify/fast never send it (PR #227 F1).
-        // mlx-lm forwards chat_template_kwargs to the chat template (mirrors the
-        // ollama path's think:false). See #220.
+        // an unclosed <think> block and emit nothing (probed 2026-08-04). One value
+        // for all phases (#231): when set (true or false) the chat_template_kwargs
+        // kwarg rides every call — so it is LOCAL-endpoint only (ollama, mlx-lm
+        // gateway); a cloud OpenAI/OpenRouter/Groq endpoint would 400 on the unknown
+        // field. provider cannot gate this (the MLX gateway is also provider:openai),
+        // so the operator leaves enableThinking unset for cloud endpoints. See #220.
+        const thinking = this.config.enableThinking;
         const body = {
             model,
             messages: [{ role: "user", content: prompt }],