@gamaze/hicortex 0.16.2 → 0.16.4

package/README.md

@@ -212,6 +212,9 @@ Config at `~/.hicortex/config.json`. Created by `init`. Key options:
 | `contextAgents` | Per-agent context modes (0.13): `{ "<id>": "override" \| "global" \| "off" }`. Absent + no `agents/<id>/` dir → every agent gets the global set. Boot-time (restart to apply) — see [Per-agent context](#per-agent-context-013) |
 | `agentName` | This install's per-agent context id sent as `?agent=`. **Unset by default** (CC shares the global context — no `?agent=` sent). Explicit opt-in via `init --agent-name <name>`; `init --agent-name ""` clears it. An empty/whitespace value equals unset |
 | `nightlyHour` | Local hour (0–23) for the nightly job installed by `init` (defaults: client 2, server 3). Applied on fresh installs; existing schedules are never overwritten |
+| `preflightTimeoutMs` | **Client mode only.** Per-attempt timeout for the nightly's server-reachability check before it starts capturing (default: 15000 ms) |
+| `preflightAttempts` | **Client mode only.** Reachability-check retries before the nightly aborts (default: 3; floored at 1). `1` = single try, no retry |
+| `preflightRetryGapMs` | **Client mode only.** Delay between reachability retries (default: 60000 ms). Note: timers don't advance while the machine is asleep, so on a sleeping laptop this gap counts awake-time, not wall-clock |
 | `scoreSimilarityWeight` | Weight of semantic similarity in the ranking score (default: 0.50) |
 | `scoreStrengthWeight` | Weight of effective strength — importance/use/recency of access (default: 0.20) |
 | `scoreConnectionsWeight` | Weight of graph centrality (default: 0.15) |

package/dist/cli.js

@@ -40,7 +40,7 @@ switch (command) {
             agentName = (0, cli_args_js_1.readValueFlag)(process.argv, "--agent-name");
         }
         catch {
-            console.error("[hicortex] init: --agent-name requires a value, e.g. --agent-name lenovo");
+            console.error("[hicortex] init: --agent-name requires a value, e.g. --agent-name my-agent");
             process.exit(1);
         }
         const repairConfig = process.argv.includes("--repair-config");

package/dist/config-read.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Strict config readers for primitive values. Pure functions — no LlmConfig
+ * dependency — shared by the nightly preflight knobs and the distill-tier
+ * overlay (llm.ts / mcp-server.ts).
+ *
+ * The point is to reject wrong-typed config values AT THE BOUNDARY (disk →
+ * runtime) with a warn, rather than casting them straight through. The trap
+ * these guard: a JSON slip like `"enableThinking": "false"` (string,
+ * not boolean) casts to a truthy value downstream — for the Qwen chat template
+ * a non-empty string flips thinking ON, which is precisely the failure the key
+ * exists to prevent, with no error anywhere. Same class as the #225
+ * preflight-knob validation.
+ */
+/**
+ * Read a positive finite number from a config object. Returns `def` when the
+ * key is absent OR present-but-invalid (with a warn in the latter case).
+ */
+export declare function readPositiveConfig(config: Record<string, unknown>, key: string, def: number): number;
+/**
+ * Read a strict boolean from a config object. Returns the boolean when valid,
+ * `undefined` when the key is absent OR present-but-not-a-boolean (with a warn
+ * in the latter case). Never coerces — `"false"` (string) is rejected, not
+ * treated as truthy.
+ */
+export declare function readStrictBoolean(config: Record<string, unknown>, key: string): boolean | undefined;

package/dist/config-read.js

@@ -0,0 +1,45 @@
+"use strict";
+/**
+ * Strict config readers for primitive values. Pure functions — no LlmConfig
+ * dependency — shared by the nightly preflight knobs and the distill-tier
+ * overlay (llm.ts / mcp-server.ts).
+ *
+ * The point is to reject wrong-typed config values AT THE BOUNDARY (disk →
+ * runtime) with a warn, rather than casting them straight through. The trap
+ * these guard: a JSON slip like `"enableThinking": "false"` (string,
+ * not boolean) casts to a truthy value downstream — for the Qwen chat template
+ * a non-empty string flips thinking ON, which is precisely the failure the key
+ * exists to prevent, with no error anywhere. Same class as the #225
+ * preflight-knob validation.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readPositiveConfig = readPositiveConfig;
+exports.readStrictBoolean = readStrictBoolean;
+/**
+ * Read a positive finite number from a config object. Returns `def` when the
+ * key is absent OR present-but-invalid (with a warn in the latter case).
+ */
+function readPositiveConfig(config, key, def) {
+    const v = config[key];
+    if (v === undefined)
+        return def;
+    if (typeof v === "number" && Number.isFinite(v) && v > 0)
+        return v;
+    console.warn(`[hicortex] config "${key}" = ${String(v)} is not a positive finite number — using default ${def}.`);
+    return def;
+}
+/**
+ * Read a strict boolean from a config object. Returns the boolean when valid,
+ * `undefined` when the key is absent OR present-but-not-a-boolean (with a warn
+ * in the latter case). Never coerces — `"false"` (string) is rejected, not
+ * treated as truthy.
+ */
+function readStrictBoolean(config, key) {
+    const v = config[key];
+    if (v === undefined)
+        return undefined;
+    if (typeof v === "boolean")
+        return v;
+    console.warn(`[hicortex] config "${key}" = ${String(v)} is not a boolean — ignored.`);
+    return undefined;
+}

package/dist/consolidate.js

@@ -832,7 +832,7 @@ function stageHubBoost(db, dryRun) {
 //
 // A later decision/correction can reverse, replace, or invalidate an earlier
 // one — e.g. "chose Ollama for distillation" superseded a month later by
-// "switched distillation to the MBP's 35B model over Tailscale". Left
+// "switched distillation to a local 35B model over a mesh VPN". Left
 // unlinked, retrieval and lesson selection can surface the stale one. This
 // stage links OLD → NEW with relationship `superseded_by` and accelerates the
 // old memory's decay, WITHOUT deleting it (unlike `hicortex dedup`'s merge —

package/dist/llm.d.ts

@@ -25,6 +25,10 @@ export interface LlmConfig {
     distillBaseUrl?: string;
     distillApiKey?: string;
     distillProvider?: string;
+    /** Max output tokens for all phases (distill/reflect/classify/scoring). Heavy phases fall back to 8192, scoring to 2048. */
+    maxTokens?: number;
+    /** Toggle thinking on the openai-compat path for the heavy phases. Absent = no kwarg sent. */
+    enableThinking?: boolean;
     /** Optional separate endpoint for reflect-tier LLM (e.g. remote Ollama with larger model). */
     reflectBaseUrl?: string;
     reflectApiKey?: string;
@@ -87,6 +91,21 @@ export type { ModelTierOverride } from "./types.js";
  * a dead score apiKey/provider under an ollama base.
  */
 export declare function applyModelsBlock(saved: Record<string, unknown> | null): Record<string, unknown> | null;
+/**
+ * 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.
+ */
+export declare function applyTierTuningOverlay(llmConfig: LlmConfig, savedConfig: Record<string, unknown> | null | undefined): void;
 /**
  * Resolve an LlmConfig from a saved ~/.hicortex/config.json object.
  *

package/dist/llm.js

@@ -18,6 +18,7 @@ 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;
@@ -25,6 +26,7 @@ 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
  * Hicortex-specific env vars only. Returns null when nothing explicit is set.
@@ -182,6 +184,31 @@ function applyModelsBlock(saved) {
     }
     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.
+ */
+function applyTierTuningOverlay(llmConfig, savedConfig) {
+    if (!savedConfig)
+        return;
+    if (savedConfig.maxTokens !== undefined) {
+        llmConfig.maxTokens = (0, config_read_js_1.readPositiveConfig)(savedConfig, "maxTokens", 8192);
+    }
+    const thinking = (0, config_read_js_1.readStrictBoolean)(savedConfig, "enableThinking");
+    if (thinking !== undefined) {
+        llmConfig.enableThinking = thinking;
+    }
+}
 /**
  * Resolve an LlmConfig from a saved ~/.hicortex/config.json object.
  *
@@ -232,6 +259,12 @@ function resolveSavedLlmConfig(savedConfig, findBinary = findClaudeBinary) {
         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.
+    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.
@@ -504,28 +537,39 @@ class LlmClient {
     /**
      * Fast-tier completion (importance scoring, simple tasks).
      */
-    async completeFast(prompt, maxTokens = 2048) {
-        return this.complete(this.config.model, prompt, maxTokens, 600_000);
+    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);
     }
     /**
      * Reflect-tier completion (nightly reflection, needs reasoning).
      * Routes to reflectBaseUrl/reflectProvider if configured (e.g. remote Ollama with larger model).
      */
-    async completeReflect(prompt, maxTokens = 8192) {
+    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, maxTokens, 900_000);
+            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, maxTokens, 900_000);
+        return this.complete(this.config.reflectModel, prompt, tokens, 900_000, thinking);
     }
     /**
      * Distillation-tier completion (session knowledge extraction).
      * Routes to distillBaseUrl/distillProvider if configured (e.g. remote Ollama with faster model).
      */
-    async completeDistill(prompt, maxTokens = 2048) {
+    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, maxTokens, 900_000);
+            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, maxTokens, 900_000);
+        return this.complete(this.config.distillModel ?? this.config.model, prompt, tokens, 900_000, thinking);
     }
     /**
      * Classification-tier completion (memory tag classification).
@@ -538,33 +582,35 @@ class LlmClient {
      *   - Only classifyModel set → the classify model on the reflect endpoint
      *     when one is configured, else on the base endpoint.
      */
-    async completeClassify(prompt, maxTokens = 8192) {
+    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, maxTokens);
+            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, maxTokens, 900_000);
+            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, maxTokens, 900_000);
+            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, maxTokens, 900_000);
+        return this.complete(model, prompt, tokens, 900_000, thinking);
     }
     /**
      * 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) {
+    async completeWithOverride(baseUrl, apiKey, provider, model, prompt, maxTokens, timeoutMs, thinking) {
         const tempClient = new LlmClient({
             ...this.config,
             baseUrl,
             apiKey,
             provider,
         });
-        return tempClient.complete(model, prompt, maxTokens, timeoutMs);
+        return tempClient.complete(model, prompt, maxTokens, timeoutMs, thinking);
     }
-    async complete(model, prompt, maxTokens, timeoutMs) {
+    async complete(model, prompt, maxTokens, timeoutMs, thinking) {
         if (this.isRateLimited) {
             throw new RateLimitError(this.rateLimitedUntil - Date.now());
         }
@@ -572,7 +618,7 @@ class LlmClient {
         let lastErr;
         for (let attempt = 0; attempt <= retryDelays.length; attempt++) {
             try {
-                return await this.completeOnce(model, prompt, maxTokens, timeoutMs);
+                return await this.completeOnce(model, prompt, maxTokens, timeoutMs, thinking);
             }
             catch (err) {
                 lastErr = err instanceof Error ? err : new Error(String(err));
@@ -589,7 +635,7 @@ class LlmClient {
         }
         throw lastErr;
     }
-    async completeOnce(model, prompt, maxTokens, timeoutMs) {
+    async completeOnce(model, prompt, maxTokens, timeoutMs, thinking) {
         if (this.config.provider === "claude-cli") {
             return this.completeClaude(model, prompt, timeoutMs);
         }
@@ -599,7 +645,10 @@ class LlmClient {
         if (this.config.provider === "anthropic") {
             return this.completeAnthropic(model, prompt, maxTokens, timeoutMs);
         }
-        return this.completeOpenAiCompat(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);
     }
     /**
      * Claude CLI: shell out to `claude -p` for subscription users.
@@ -711,7 +760,7 @@ class LlmClient {
     /**
      * OpenAI-compatible /v1/chat/completions (works for OpenAI, OpenRouter, etc).
      */
-    async completeOpenAiCompat(model, prompt, maxTokens, timeoutMs) {
+    async completeOpenAiCompat(model, prompt, maxTokens, timeoutMs, thinking) {
         const baseUrl = this.config.baseUrl.replace(/\/$/, "");
         // Some providers include the API version in the base URL already
         const hasVersion = /\/v\d+\/?$/.test(baseUrl);
@@ -724,14 +773,24 @@ class LlmClient {
         if (this.config.apiKey) {
             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.
+        const body = {
+            model,
+            messages: [{ role: "user", content: prompt }],
+            max_tokens: maxTokens,
+        };
+        if (thinking !== undefined) {
+            body.chat_template_kwargs = { enable_thinking: thinking };
+        }
         const resp = await fetch(url, {
             method: "POST",
             headers,
-            body: JSON.stringify({
-                model,
-                messages: [{ role: "user", content: prompt }],
-                max_tokens: maxTokens,
-            }),
+            body: JSON.stringify(body),
             signal: AbortSignal.timeout(timeoutMs),
         });
         if (resp.status === 429)

package/dist/mcp-server.js

@@ -424,6 +424,10 @@ async function startServer(options = {}) {
             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.
+        (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;

package/dist/nightly.js

@@ -55,6 +55,7 @@ try {
 }
 catch { }
 const db_js_1 = require("./db.js");
+const config_read_js_1 = require("./config-read.js");
 const llm_js_1 = require("./llm.js");
 const embedder_js_1 = require("./embedder.js");
 const storage = __importStar(require("./storage.js"));
@@ -187,6 +188,9 @@ function captureLockWaitMs() {
     const env = Number(process.env.HICORTEX_CAPTURE_LOCK_WAIT_MS);
     return Number.isFinite(env) && env >= 0 ? env : CAPTURE_LOCK_WAIT_MS;
 }
+// readPositiveConfig moved to ./config-read.ts (shared with the distill-tier
+// overlay in llm.ts / mcp-server.ts). Validates positive-number config knobs
+// at the disk→runtime boundary with a warn-on-rejected-value.
 const NIGHTLY_LOG_MAX_BYTES = 1024 * 1024; // 1 MB — years of normal runs
 /**
  * Keep ~/.hicortex/nightly.log bounded. The launchd plist and systemd unit
@@ -489,16 +493,72 @@ async function runClientNightly(config, dryRun, stateDir = HICORTEX_HOME, recapt
     const authToken = config.authToken;
     console.log(`[hicortex] Client nightly starting${dryRun ? " (dry run)" : ""}`);
     console.log(`[hicortex] Server: ${serverUrl}`);
-    // Verify server is reachable
-    try {
-        const resp = await fetch(`${serverUrl}/health`, { signal: AbortSignal.timeout(5000) });
-        if (!resp.ok)
-            throw new Error(`HTTP ${resp.status}`);
-        const data = await resp.json();
-        console.log(`[hicortex] Server OK: v${data.version}, ${data.memories} memories`);
+    // Verify server is reachable. Retry so a client waking from sleep (its
+    // network link not yet re-established) or a transient blip doesn't abort
+    // the whole run — the pre-flight only needs the link back, which can take
+    // ~1 min after wake.
+    //
+    // Config-overridable (#163): a wired Pi vs a sleeping laptop want different
+    // values. Defaults: 15s per-attempt timeout, 3 attempts, 60s gap.
+    //
+    // WALL-CLOCK NOTE: setTimeout and AbortSignal.timeout do NOT advance while
+    // macOS is asleep, so the ~2m45s worst case (3×15s + 2×60s) is wall-clock-
+    // optimistic — a sleeping laptop can straddle sleep cycles and the real
+    // elapsed time can exceed it. Not a defect: the capture lock isn't held
+    // during the retry and the cursor design is dup-over-loss, so a late success
+    // is harmless. Just don't treat 2m45s as a hard wall-clock bound.
+    const PREFLIGHT_TIMEOUT_MS = (0, config_read_js_1.readPositiveConfig)(config, "preflightTimeoutMs", 15_000);
+    const PREFLIGHT_ATTEMPTS = Math.max(1, Math.floor((0, config_read_js_1.readPositiveConfig)(config, "preflightAttempts", 3)));
+    const PREFLIGHT_RETRY_GAP_MS = (0, config_read_js_1.readPositiveConfig)(config, "preflightRetryGapMs", 60_000);
+    let reachable = false;
+    for (let attempt = 1; attempt <= PREFLIGHT_ATTEMPTS; attempt++) {
+        try {
+            const resp = await fetch(`${serverUrl}/health`, { signal: AbortSignal.timeout(PREFLIGHT_TIMEOUT_MS) });
+            if (!resp.ok)
+                throw new Error(`HTTP ${resp.status}`);
+            const data = await resp.json();
+            console.log(`[hicortex] Server OK: v${data.version}, ${data.memories} memories`);
+            reachable = true;
+            break;
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            if (attempt < PREFLIGHT_ATTEMPTS) {
+                console.error(`[hicortex] Server unreachable at ${serverUrl} (attempt ${attempt}/${PREFLIGHT_ATTEMPTS}): ${msg} — retrying in ${PREFLIGHT_RETRY_GAP_MS / 1000}s`);
+                await new Promise((r) => setTimeout(r, PREFLIGHT_RETRY_GAP_MS));
+            }
+            else {
+                console.error(`[hicortex] Server unreachable at ${serverUrl} after ${PREFLIGHT_ATTEMPTS} attempts: ${msg}`);
+            }
+        }
     }
-    catch (err) {
-        console.error(`[hicortex] Server unreachable at ${serverUrl}: ${err instanceof Error ? err.message : String(err)}`);
+    if (!reachable) {
+        // The abort was invisible for weeks once: a plain `return` let the oneshot
+        // exit 0, so systemd/launchd recorded success and the capture gap went
+        // unnoticed. Exit non-zero so `systemctl --user status` / launchd show the
+        // unit failed (safe — this is a timer-driven oneshot with no Restart=, so
+        // no loop), and fire the telemetry ping (ok=false) so the abort is
+        // distinguishable from "powered off / uninstalled" in the activity aggregate.
+        process.exitCode = 1;
+        if (!dryRun && (0, telemetry_js_1.isTelemetryEnabled)(config)) {
+            await (0, telemetry_js_1.sendTelemetry)({
+                id: (0, telemetry_js_1.getTelemetryId)(stateDir),
+                v: VERSION,
+                pv: telemetry_js_1.TELEMETRY_PAYLOAD_VERSION,
+                event: "nightly",
+                mode: "client",
+                // `agent` deliberately OMITTED: no transcripts have been read at
+                // pre-flight, so the type is genuinely unknown. The admin summary
+                // buckets a missing agent as "?" (distinct from cc/pi/oc/mixed) —
+                // sending "cc" here would miscount an aborting Hermes/OC-only client
+                // as a cc install. The success-path ping sends the real type once
+                // session sources are known.
+                mem: 0,
+                lessons: 0,
+                sessions: 0,
+                ok: false,
+            });
+        }
         console.error(`[hicortex] Aborting. Will retry next run.`);
         return; // Don't update last-run so we retry
     }

package/dist/pi-transcript-reader.d.ts

@@ -19,7 +19,7 @@
  *     --home-alice-projects-myagent--/
  *       2026-04-10T18-37-44-615Z_<uuid>.jsonl
  *       2026-04-11T07-51-28-282Z_<uuid>.jsonl
- *     --home-agents-Development-MAIC--/
+ *     --home-user-projects-ExampleApp--/
  *       ...
  *
  * The encoded-cwd uses double-dash separators: /home/alice/projects/myagent

package/dist/pi-transcript-reader.js

@@ -20,7 +20,7 @@
  *     --home-alice-projects-myagent--/
  *       2026-04-10T18-37-44-615Z_<uuid>.jsonl
  *       2026-04-11T07-51-28-282Z_<uuid>.jsonl
- *     --home-agents-Development-MAIC--/
+ *     --home-user-projects-ExampleApp--/
  *       ...
  *
  * The encoded-cwd uses double-dash separators: /home/alice/projects/myagent

package/dist/recall-index.d.ts

@@ -75,8 +75,8 @@ export declare function formatIndexLine(r: MemorySearchResult & {
  * NOTE: FTS hits BYPASS the similarity floor, so raising the floor shifts
  * weight toward FTS-sourced entries. In practice FTS is currently inert on
  * real prompts — eval #3 had 0 FTS rows / 2,208 (2,203 vector + 5 graph), and
- * a 12-prompt live bedrock sample returned 96/96 vector — so the floor change
- * is safe as measured. But FTS quality is unmeasured; if FTS starts firing
+ * a relevance sample returned 96/96 vector — so the floor change is safe as
+ * measured. But FTS quality is unmeasured; if FTS starts firing
  * (e.g. as #205's fielded-BM25 retune beds in), give it its own eval.
  */
 export declare function passesRelevanceGate(r: MemorySearchResult, minSimilarity: number): boolean;

package/dist/recall-index.js

@@ -129,8 +129,8 @@ function formatIndexLine(r, maxLen = DEFAULT_TITLE_CHARS) {
  * NOTE: FTS hits BYPASS the similarity floor, so raising the floor shifts
  * weight toward FTS-sourced entries. In practice FTS is currently inert on
  * real prompts — eval #3 had 0 FTS rows / 2,208 (2,203 vector + 5 graph), and
- * a 12-prompt live bedrock sample returned 96/96 vector — so the floor change
- * is safe as measured. But FTS quality is unmeasured; if FTS starts firing
+ * a relevance sample returned 96/96 vector — so the floor change is safe as
+ * measured. But FTS quality is unmeasured; if FTS starts firing
  * (e.g. as #205's fielded-BM25 retune beds in), give it its own eval.
  */
 function passesRelevanceGate(r, minSimilarity) {

package/dist/redact.d.ts

@@ -5,8 +5,8 @@
  * Why this exists:
  *   - Session transcripts contain tool output: file reads, command output,
  *     env var dumps. These regularly contain API keys, tokens, and paths.
- *   - The distillation LLM is often remote (e.g., Ollama on MBP via
- *     Tailscale). Secrets in the transcript travel over the network.
+ *   - The distillation LLM is often remote (e.g., a mesh VPN link to a
+ *     GPU box). Secrets in the transcript travel over the network.
  *   - Even if the LLM correctly classifies the memory as SENSITIVE, the
  *     secret is already stored and searchable via hicortex_search.
  *   - Redaction runs BEFORE the LLM sees the text, eliminating the risk.

package/dist/redact.js

@@ -6,8 +6,8 @@
  * Why this exists:
  *   - Session transcripts contain tool output: file reads, command output,
  *     env var dumps. These regularly contain API keys, tokens, and paths.
- *   - The distillation LLM is often remote (e.g., Ollama on MBP via
- *     Tailscale). Secrets in the transcript travel over the network.
+ *   - The distillation LLM is often remote (e.g., a mesh VPN link to a
+ *     GPU box). Secrets in the transcript travel over the network.
  *   - Even if the LLM correctly classifies the memory as SENSITIVE, the
  *     secret is already stored and searchable via hicortex_search.
  *   - Redaction runs BEFORE the LLM sees the text, eliminating the risk.

package/dist/telemetry.d.ts

@@ -6,7 +6,11 @@
  *   v        — package version
  *   pv       — payload schema version
  *   mode     — server or client
- *   agent    — cc, pi, oc, or mixed (detected from session sources)
+ *   agent    — cc, pi, oc, or mixed (detected from session sources); OMITTED
+ *              when the agent type is genuinely unknown (pre-flight abort — no
+ *              transcripts read yet). The admin summary buckets a missing agent
+ *              as "?", distinct from any real type, so an aborting Hermes/OC
+ *              client is never miscounted as "cc".
  *   mem      — total memory count
  *   lessons  — total lesson count
  *   sessions — sessions distilled this run
@@ -41,7 +45,14 @@ export interface TelemetryPayload {
     id: string;
     v: string;
     mode: string;
-    agent: string;
+    /**
+     * Agent type detected from session sources (cc/pi/oc/mixed). OMITTED when
+     * unknown — currently only the pre-flight abort path, where no transcripts
+     * have been read yet (sending "cc" there mislabelled aborting Hermes/OC
+     * clients in the admin aggregate). The admin summary buckets a missing agent
+     * as "?", which is the honest signal.
+     */
+    agent?: string;
     mem: number;
     lessons: number;
     sessions: number;

package/dist/telemetry.js

@@ -7,7 +7,11 @@
  *   v        — package version
  *   pv       — payload schema version
  *   mode     — server or client
- *   agent    — cc, pi, oc, or mixed (detected from session sources)
+ *   agent    — cc, pi, oc, or mixed (detected from session sources); OMITTED
+ *              when the agent type is genuinely unknown (pre-flight abort — no
+ *              transcripts read yet). The admin summary buckets a missing agent
+ *              as "?", distinct from any real type, so an aborting Hermes/OC
+ *              client is never miscounted as "cc".
  *   mem      — total memory count
  *   lessons  — total lesson count
  *   sessions — sessions distilled this run

package/dist/types.d.ts

@@ -54,7 +54,7 @@ export interface MemorySearchResult {
     access_count: number;
     memory_type: string;
     project: string | null;
-    /** Origin agent (e.g. "hermes/atlas", "cc/mbp5") — surfaced in the recall
+    /** Origin agent (e.g. "hermes/profile-name", "cc/machine-name") — surfaced in the recall
      *  one-liner so agents can calibrate trust (#202 provenance). Optional on the
      *  result type (matches how `domain` is threaded) to avoid breaking fixtures. */
     source_agent?: string | null;
@@ -260,6 +260,49 @@ export interface HicortexConfig {
      * near its lower tail). See domains.example.json for a worked example.
      */
     weakPrimaryFloor?: number;
+    /**
+     * Per-attempt timeout (ms) for the CLIENT nightly's pre-flight GET /health
+     * check before capturing (#163). Default 15000. Overridable per machine —
+     * a wired Pi vs a sleeping laptop want different values. See runClientNightly
+     * in nightly.ts. No effect in server mode (server capture is localhost).
+     */
+    preflightTimeoutMs?: number;
+    /**
+     * Max attempts for the client nightly's pre-flight /health retry loop (#163).
+     * Default 3. Attempts are spaced preflightRetryGapMs apart; on exhaustion the
+     * run aborts with a non-zero exit code and an ok=false telemetry ping so the
+     * failure is visible to systemd/launchd and the activity aggregate.
+     */
+    preflightAttempts?: number;
+    /**
+     * Gap (ms) between pre-flight /health attempts in the client nightly (#163).
+     * Default 60000. Wall-clock-optimistic on a sleeping laptop — setTimeout does
+     * NOT advance while macOS is asleep, so real elapsed time can exceed the
+     * nominal worst case. Not a defect (capture lock isn't held; cursor design is
+     * dup-over-loss); just don't treat the nominal sum as a hard bound.
+     */
+    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
+     * 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.
+     */
+    enableThinking?: boolean;
 }
 /** A config-owned life-sphere domain (see HicortexConfig.domains). */
 export interface DomainDef {

package/hermes-plugin/hicortex/config.py

@@ -27,7 +27,7 @@ CONFIG_SCHEMA: list[dict[str, Any]] = [
         "description": (
             "URL of the Hicortex memory server. On the server host use "
             "http://localhost:8787; on other machines use the server's "
-            "Tailscale hostname, e.g. http://memory-server:8787."
+            "private hostname, e.g. http://memory-server:8787."
         ),
         "default": "http://localhost:8787",
         "required": True,

package/hermes-plugin/hicortex/provider.py

@@ -210,7 +210,8 @@ class HicortexProvider(MemoryProvider):
             self._recall_limit = 5
         self._privacy = cfg.get("privacy_filter", "WORK,PERSONAL")
         # #203 scope: declared knowledge domains for this role-bound agent
-        # (e.g. Lenny → Health). Soft affinity boost on recall; never excludes.
+        # (e.g. a health-focused agent → Health). Soft affinity boost on
+        # recall; never excludes.
         _md_raw = cfg.get("mission_domains") or ""
         self._mission_domains = [d.strip() for d in _md_raw.split(",") if d.strip()]
         self._agent_name = _resolve_agent_name(cfg)

package/package.json

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