@gamaze/hicortex 0.4.1 → 0.4.2

package/README.md

@@ -71,7 +71,7 @@ npx @gamaze/hicortex uninstall                 # Remove CC integration (keeps DB
 ## Architecture
 
 ```
-  Client (MBP)              Server (bedrock)          Client (MBA)
+  Client A                  Server                    Client B
   ┌──────────┐              ┌──────────────┐          ┌──────────┐
   │CC sessions│              │   Shared DB   │          │CC sessions│
   │    ↓      │  POST        │              │  POST    │    ↓      │
@@ -99,6 +99,7 @@ Config at `~/.hicortex/config.json`. Created by `init`. Key options:
 | `serverUrl` | Remote server URL (client mode) |
 | `llmModel` | Model for importance scoring |
 | `distillModel` | Model for session distillation (9b+ recommended) |
+| `distillBaseUrl` | Separate Ollama instance for distillation |
 | `reflectModel` | Model for nightly reflection (largest available) |
 | `reflectBaseUrl` | Separate Ollama instance for reflection |
 | `authToken` | Bearer token for endpoint auth |

package/dist/claude-md.d.ts

@@ -1,15 +1,16 @@
 /**
  * CLAUDE.md lesson injection — manages the Hicortex Learnings block.
  *
- * Writes a delimited block into ~/.claude/CLAUDE.md containing:
- * - Agent guidance for proactive tool use
- * - Active lessons from the DB
+ * Injects a dynamic, nightly-updated block into ~/.claude/CLAUDE.md:
+ * - Top lessons (from reflection, high-confidence)
+ * - Memory index (projects + counts, primes the agent to search)
+ * - Current project context (recent decisions for this project)
  *
- * Idempotent: calling twice with the same lessons produces the same file.
+ * Idempotent: calling twice with the same data produces the same file.
  */
 import type Database from "better-sqlite3";
 /**
- * Inject lessons from the DB into CLAUDE.md.
+ * Inject lessons, memory index, and project context into CLAUDE.md.
  * Creates the file if it doesn't exist.
  * Replaces existing block if present, appends if not.
  */

package/dist/claude-md.js

@@ -2,11 +2,12 @@
 /**
  * CLAUDE.md lesson injection — manages the Hicortex Learnings block.
  *
- * Writes a delimited block into ~/.claude/CLAUDE.md containing:
- * - Agent guidance for proactive tool use
- * - Active lessons from the DB
+ * Injects a dynamic, nightly-updated block into ~/.claude/CLAUDE.md:
+ * - Top lessons (from reflection, high-confidence)
+ * - Memory index (projects + counts, primes the agent to search)
+ * - Current project context (recent decisions for this project)
  *
- * Idempotent: calling twice with the same lessons produces the same file.
+ * Idempotent: calling twice with the same data produces the same file.
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -46,42 +47,67 @@ exports.injectLessons = injectLessons;
 exports.removeLessonsBlock = removeLessonsBlock;
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
-const node_path_2 = require("node:path");
 const node_os_1 = require("node:os");
 const storage = __importStar(require("./storage.js"));
 const license_js_1 = require("./license.js");
 const START_MARKER = "<!-- HICORTEX-LEARNINGS:START -->";
 const END_MARKER = "<!-- HICORTEX-LEARNINGS:END -->";
-const DEFAULT_CLAUDE_MD = (0, node_path_2.join)((0, node_os_1.homedir)(), ".claude", "CLAUDE.md");
-const AGENT_GUIDANCE = `You have access to long-term memory via Hicortex MCP tools. Use \`hicortex_search\` when you need context from past sessions, decisions, or prior work. Use \`hicortex_context\` at session start to recall recent project state. Use \`hicortex_ingest\` to save important decisions or learnings. Sessions are auto-captured nightly.`;
+const DEFAULT_CLAUDE_MD = (0, node_path_1.join)((0, node_os_1.homedir)(), ".claude", "CLAUDE.md");
 /**
- * Inject lessons from the DB into CLAUDE.md.
+ * Inject lessons, memory index, and project context into CLAUDE.md.
  * Creates the file if it doesn't exist.
  * Replaces existing block if present, appends if not.
  */
 function injectLessons(db, options = {}) {
     const claudeMdPath = options.claudeMdPath ?? DEFAULT_CLAUDE_MD;
-    const stateDir = options.stateDir ?? (0, node_path_2.join)((0, node_os_1.homedir)(), ".hicortex");
-    // Determine lesson limit based on license
+    const stateDir = options.stateDir ?? (0, node_path_1.join)((0, node_os_1.homedir)(), ".hicortex");
+    // Determine limits based on license
     const features = (0, license_js_1.getFeatures)(stateDir);
-    const maxLessons = features.maxMemories === -1 ? 15 : 7;
-    // Load lessons
+    const maxLessons = features.maxMemories === -1 ? 10 : 5;
+    // --- Lessons ---
     const lessons = storage.getLessons(db, 30, options.project);
     const selected = lessons.slice(0, maxLessons);
-    // Format lesson lines
     const lessonLines = selected.map((l) => {
-        const match = l.content.match(/## Lesson: (.+)/);
-        return match ? `- ${match[1]}` : `- ${l.content.slice(0, 200)}`;
+        const titleMatch = l.content.match(/## Lesson: (.+)/);
+        const typeMatch = l.content.match(/\*\*Type:\*\* (\w+)/);
+        const severityMatch = l.content.match(/\*\*Severity:\*\* (\w+)/);
+        const title = titleMatch ? titleMatch[1] : l.content.slice(0, 150);
+        const meta = [severityMatch?.[1], typeMatch?.[1]].filter(Boolean).join(", ");
+        return `- ${title}${meta ? ` (${meta})` : ""}`;
     });
-    // Build the block
-    const blockParts = [START_MARKER, "## Hicortex Learnings", "", AGENT_GUIDANCE];
+    // --- Memory Index ---
+    const projectIndex = buildProjectIndex(db);
+    const totalCount = storage.countMemories(db);
+    const lessonCount = lessons.length;
+    const sourceCount = countSources(db);
+    // --- Current Project Context ---
+    const currentProject = detectCurrentProject(claudeMdPath);
+    const projectContext = currentProject
+        ? buildProjectContext(db, currentProject)
+        : [];
+    // --- Build Block ---
+    const blockParts = [START_MARKER, "## Hicortex Memory"];
+    // Mandatory instruction
+    blockParts.push("", "You have access to shared long-term memory across all agents and sessions.", "BEFORE making decisions, search memory: `hicortex_search` for prior decisions on the same topic.", "Use `hicortex_context` at session start for recent project state.");
+    // Lessons
     if (lessonLines.length > 0) {
-        blockParts.push("", "### Active Lessons");
+        blockParts.push("", "### Lessons (updated nightly)");
         blockParts.push(...lessonLines);
     }
+    // Project context
+    if (projectContext.length > 0) {
+        blockParts.push("", `### This Project (${currentProject})`);
+        blockParts.push(...projectContext);
+    }
+    // Memory index
+    if (projectIndex.length > 0) {
+        blockParts.push("", "### Memory Index");
+        blockParts.push(projectIndex.join(" | "));
+        blockParts.push(`${totalCount} memories, ${lessonCount} lessons, ${sourceCount} agents. Search with \`hicortex_search\`.`);
+    }
     blockParts.push(END_MARKER);
     const block = blockParts.join("\n");
-    // Read existing file or start empty
+    // --- Write ---
     let content = "";
     try {
         content = (0, node_fs_1.readFileSync)(claudeMdPath, "utf-8");
@@ -89,31 +115,94 @@ function injectLessons(db, options = {}) {
     catch {
         // File doesn't exist — will create it
     }
-    // Replace or append
     const startIdx = content.indexOf(START_MARKER);
     const endIdx = content.indexOf(END_MARKER);
     if (startIdx !== -1 && endIdx !== -1) {
-        // Replace existing block
         content =
             content.slice(0, startIdx) +
                 block +
                 content.slice(endIdx + END_MARKER.length);
     }
     else {
-        // Append with blank line separator
-        if (content.length > 0 && !content.endsWith("\n")) {
+        if (content.length > 0 && !content.endsWith("\n"))
             content += "\n";
-        }
-        if (content.length > 0) {
+        if (content.length > 0)
             content += "\n";
-        }
         content += block + "\n";
     }
-    // Write
     (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(claudeMdPath), { recursive: true });
     (0, node_fs_1.writeFileSync)(claudeMdPath, content);
     return { lessonsCount: selected.length, path: claudeMdPath };
 }
+/**
+ * Build compact project index: "hicortex: 18 | boat: 24 | health: 45"
+ */
+function buildProjectIndex(db) {
+    try {
+        const rows = db
+            .prepare(`SELECT project, COUNT(*) as cnt FROM memories
+         WHERE project IS NOT NULL
+         GROUP BY project ORDER BY cnt DESC LIMIT 10`)
+            .all();
+        return rows.map((r) => `${r.project}: ${r.cnt}`);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Count distinct source agents.
+ */
+function countSources(db) {
+    try {
+        return db
+            .prepare("SELECT COUNT(DISTINCT source_agent) as cnt FROM memories")
+            .get().cnt;
+    }
+    catch {
+        return 0;
+    }
+}
+/**
+ * Detect current project from the CLAUDE.md path.
+ * CC puts project-specific CLAUDE.md files in ~/.claude/projects/<encoded-path>/
+ * The global ~/.claude/CLAUDE.md has no project context.
+ */
+function detectCurrentProject(claudeMdPath) {
+    // Global CLAUDE.md — no project
+    if (claudeMdPath === DEFAULT_CLAUDE_MD)
+        return null;
+    // Project CLAUDE.md: ~/.claude/projects/-Users-foo-myproject/CLAUDE.md
+    // Extract the last segment of the encoded path
+    const match = claudeMdPath.match(/projects\/[^/]*-([^/]+)\//);
+    if (match)
+        return match[1];
+    return null;
+}
+/**
+ * Build recent decisions/facts for a specific project.
+ * Returns formatted lines like: "- Shipped v0.4.1 with multi-client (2026-03-28)"
+ */
+function buildProjectContext(db, project) {
+    try {
+        const rows = db
+            .prepare(`SELECT content, created_at FROM memories
+         WHERE project = ? AND memory_type IN ('decision', 'episode')
+         ORDER BY created_at DESC LIMIT 5`)
+            .all(project);
+        return rows.map((r) => {
+            const date = r.created_at?.slice(0, 10) ?? "";
+            // Extract first meaningful line from content
+            const lines = r.content.split("\n").filter((l) => l.trim().length > 10);
+            const summary = lines.find((l) => l.startsWith("- ") || l.startsWith("### "))?.replace(/^[-#\s]+/, "").slice(0, 120) ??
+                r.content.slice(0, 120);
+            return `- ${summary} (${date})`;
+        });
+    }
+    catch {
+        return [];
+    }
+}
 /**
  * Remove the Hicortex Learnings block from CLAUDE.md.
  * Used by the uninstall command.
@@ -124,16 +213,14 @@ function removeLessonsBlock(claudeMdPath = DEFAULT_CLAUDE_MD) {
         content = (0, node_fs_1.readFileSync)(claudeMdPath, "utf-8");
     }
     catch {
-        return false; // File doesn't exist
+        return false;
     }
     const startIdx = content.indexOf(START_MARKER);
     const endIdx = content.indexOf(END_MARKER);
     if (startIdx === -1 || endIdx === -1)
         return false;
-    // Remove block and any trailing blank line
     let newContent = content.slice(0, startIdx) +
         content.slice(endIdx + END_MARKER.length);
-    // Clean up double blank lines left by removal
     newContent = newContent.replace(/\n{3,}/g, "\n\n").trim();
     if (newContent.length > 0)
         newContent += "\n";

package/dist/distiller.d.ts

@@ -4,12 +4,20 @@
  * not from filesystem scanning.
  */
 import type { LlmClient } from "./llm.js";
+/**
+ * Estimate a safe chunk size in chars based on the LLM provider and model.
+ * - API providers (Anthropic, OpenAI, claude-cli): no chunking needed (large context windows)
+ * - Ollama: query /api/show for context_length, use ~60% for chunks (leaving room for prompt + generation)
+ * - Fallback: 20K chars (~5K tokens) — safe for 4B models with 32K context
+ */
+export declare function detectChunkSize(provider: string, model: string, baseUrl?: string): Promise<number>;
 /**
  * Convert OpenClaw hook messages to a filtered transcript string.
  */
 export declare function extractConversationText(messages: unknown[]): string;
 /**
  * Send filtered conversation to LLM for knowledge extraction.
+ * For large transcripts, chunks into segments to avoid overwhelming small models.
  * Returns an array of memory entries to ingest, or empty array if nothing worth extracting.
  */
-export declare function distillSession(llm: LlmClient, conversation: string, projectName: string, date: string): Promise<string[]>;
+export declare function distillSession(llm: LlmClient, conversation: string, projectName: string, date: string, chunkSizeChars?: number): Promise<string[]>;

package/dist/distiller.js

@@ -5,11 +5,53 @@
  * not from filesystem scanning.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectChunkSize = detectChunkSize;
 exports.extractConversationText = extractConversationText;
 exports.distillSession = distillSession;
 const prompts_js_1 = require("./prompts.js");
 const MAX_TRANSCRIPT_CHARS = 80_000;
 const MIN_CONVERSATION_CHARS = 200;
+/**
+ * Estimate a safe chunk size in chars based on the LLM provider and model.
+ * - API providers (Anthropic, OpenAI, claude-cli): no chunking needed (large context windows)
+ * - Ollama: query /api/show for context_length, use ~60% for chunks (leaving room for prompt + generation)
+ * - Fallback: 20K chars (~5K tokens) — safe for 4B models with 32K context
+ */
+async function detectChunkSize(provider, model, baseUrl) {
+    // API-based providers handle large contexts natively — no chunking needed
+    if (provider !== "ollama") {
+        return MAX_TRANSCRIPT_CHARS;
+    }
+    // Query Ollama for model metadata
+    if (baseUrl) {
+        try {
+            const resp = await fetch(`${baseUrl}/api/show`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ name: model }),
+                signal: AbortSignal.timeout(5000),
+            });
+            if (resp.ok) {
+                const data = await resp.json();
+                // Try to extract context length from model_info
+                const info = data.model_info ?? {};
+                const ctxKey = Object.keys(info).find((k) => k.endsWith("context_length") || k.endsWith("context_window"));
+                if (ctxKey && typeof info[ctxKey] === "number") {
+                    const contextTokens = info[ctxKey];
+                    // Use 60% of context for chunk input (~4 chars/token)
+                    const chunkChars = Math.floor(contextTokens * 0.6 * 4);
+                    console.log(`[hicortex]     Model context: ${contextTokens} tokens, chunk size: ${chunkChars} chars`);
+                    return Math.min(chunkChars, MAX_TRANSCRIPT_CHARS);
+                }
+            }
+        }
+        catch {
+            // Failed to query — use fallback
+        }
+    }
+    // Fallback: 20K chars (~5K tokens) — safe for 4B models with 32K context
+    return 20_000;
+}
 // Entry types to skip entirely (from the Python distiller)
 const SKIP_ENTRY_TYPES = new Set([
     "progress",
@@ -128,17 +170,54 @@ function extractConversationText(messages) {
 }
 /**
  * Send filtered conversation to LLM for knowledge extraction.
+ * For large transcripts, chunks into segments to avoid overwhelming small models.
  * Returns an array of memory entries to ingest, or empty array if nothing worth extracting.
  */
-async function distillSession(llm, conversation, projectName, date) {
+async function distillSession(llm, conversation, projectName, date, chunkSizeChars) {
     if (conversation.length < MIN_CONVERSATION_CHARS) {
         return [];
     }
-    // Truncate if too long
+    // Cap total input at MAX_TRANSCRIPT_CHARS
     let transcript = conversation;
     if (transcript.length > MAX_TRANSCRIPT_CHARS) {
         transcript = transcript.slice(0, MAX_TRANSCRIPT_CHARS) + "\n\n[...truncated...]";
     }
+    // Use provided chunk size or default to no chunking
+    const chunkSize = chunkSizeChars ?? MAX_TRANSCRIPT_CHARS;
+    // If transcript fits in one chunk, distill directly
+    if (transcript.length <= chunkSize) {
+        return distillChunk(llm, transcript, projectName, date);
+    }
+    // Chunk large transcripts and distill each segment
+    const chunks = splitIntoChunks(transcript, chunkSize);
+    console.log(`[hicortex]     Chunking ${transcript.length} chars into ${chunks.length} segments`);
+    const allEntries = [];
+    const seen = new Set();
+    for (let i = 0; i < chunks.length; i++) {
+        console.log(`[hicortex]     Chunk ${i + 1}/${chunks.length} (${chunks[i].length} chars)`);
+        try {
+            const entries = await distillChunk(llm, chunks[i], projectName, date);
+            for (const entry of entries) {
+                // Deduplicate by normalized content
+                const key = entry.toLowerCase().replace(/\s+/g, " ").slice(0, 100);
+                if (!seen.has(key)) {
+                    seen.add(key);
+                    allEntries.push(entry);
+                }
+            }
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            console.error(`[hicortex]     Chunk ${i + 1} failed: ${msg}`);
+            // Continue with remaining chunks — partial extraction is better than none
+        }
+    }
+    return allEntries;
+}
+/**
+ * Distill a single chunk of conversation text.
+ */
+async function distillChunk(llm, transcript, projectName, date) {
     const prompt = (0, prompts_js_1.distillation)(projectName, date, transcript);
     try {
         const result = await llm.completeDistill(prompt);
@@ -147,7 +226,6 @@ async function distillSession(llm, conversation, projectName, date) {
         if (result === "NO_EXTRACT" || result.slice(0, 20).includes("NO_EXTRACT")) {
             return [];
         }
-        // Split distilled markdown into individual memory entries
         return parseDistilledEntries(result);
     }
     catch (err) {
@@ -156,6 +234,35 @@ async function distillSession(llm, conversation, projectName, date) {
         return [];
     }
 }
+/**
+ * Split transcript text into chunks at natural boundaries (double newlines).
+ * Each chunk is at most maxChars, split at the last paragraph boundary.
+ */
+function splitIntoChunks(text, maxChars) {
+    if (text.length <= maxChars)
+        return [text];
+    const chunks = [];
+    let remaining = text;
+    while (remaining.length > 0) {
+        if (remaining.length <= maxChars) {
+            chunks.push(remaining);
+            break;
+        }
+        // Find the last paragraph break within maxChars
+        let splitAt = remaining.lastIndexOf("\n\n", maxChars);
+        if (splitAt < maxChars * 0.5) {
+            // No good paragraph break — fall back to last newline
+            splitAt = remaining.lastIndexOf("\n", maxChars);
+        }
+        if (splitAt < maxChars * 0.3) {
+            // No good break at all — hard split
+            splitAt = maxChars;
+        }
+        chunks.push(remaining.slice(0, splitAt).trim());
+        remaining = remaining.slice(splitAt).trim();
+    }
+    return chunks.filter((c) => c.length >= MIN_CONVERSATION_CHARS);
+}
 /**
  * Parse distilled markdown into individual memory entry strings.
  * Each section item becomes a separate memory.

package/dist/init.js

@@ -717,7 +717,7 @@ async function runInit(options = {}) {
         catch { /* new file */ }
         const block = [
             "<!-- HICORTEX-LEARNINGS:START -->",
-            "## Hicortex Learnings",
+            "## Hicortex Memory",
             "",
             "You have access to long-term memory via Hicortex MCP tools. Use `hicortex_search` when you need context from past sessions, decisions, or prior work. Use `hicortex_context` at session start to recall recent project state. Use `hicortex_ingest` to save important decisions or learnings. Sessions are auto-captured nightly.",
             "<!-- HICORTEX-LEARNINGS:END -->",
@@ -858,7 +858,7 @@ async function runClientInit(serverUrl) {
         catch { }
         const block = [
             "<!-- HICORTEX-LEARNINGS:START -->",
-            "## Hicortex Learnings",
+            "## Hicortex Memory",
             "",
             "You have access to long-term memory via Hicortex MCP tools. Use `hicortex_search` when you need context from past sessions, decisions, or prior work. Use `hicortex_context` at session start to recall recent project state. Use `hicortex_ingest` to save important decisions or learnings. Sessions are auto-captured nightly.",
             "<!-- HICORTEX-LEARNINGS:END -->",

package/dist/llm.d.ts

@@ -25,6 +25,10 @@ export interface LlmConfig {
     provider: string;
     /** Optional separate model for distillation (defaults to model if unset). */
     distillModel?: string;
+    /** Optional separate endpoint for distillation (e.g. remote Ollama with larger/faster model). */
+    distillBaseUrl?: string;
+    distillApiKey?: string;
+    distillProvider?: string;
     /** Optional separate endpoint for reflect-tier LLM (e.g. remote Ollama with larger model). */
     reflectBaseUrl?: string;
     reflectApiKey?: string;
@@ -59,6 +63,17 @@ export declare function findClaudeBinary(): string | null;
  * baseUrl field stores the path to the claude binary.
  */
 export declare function claudeCliConfig(claudePath: string): LlmConfig;
+/**
+ * Check if a local Ollama instance is reachable and has models loaded.
+ * Returns the model name if available, null otherwise.
+ */
+export declare function probeOllama(baseUrl?: string): Promise<string | null>;
+/**
+ * For batch operations (nightly pipeline), prefer Ollama when available.
+ * Claude CLI has strict rate limits that kill batch distillation.
+ * Falls back to the provided config if Ollama is unreachable.
+ */
+export declare function preferOllamaForBatch(resolved: LlmConfig, ollamaBaseUrl?: string): Promise<LlmConfig>;
 export declare class RateLimitError extends Error {
     retryAfterMs: number;
     constructor(retryAfterMs: number);
@@ -81,6 +96,7 @@ export declare class LlmClient {
     completeReflect(prompt: string, maxTokens?: number): Promise<string>;
     /**
      * Distillation-tier completion (session knowledge extraction).
+     * Routes to distillBaseUrl/distillProvider if configured (e.g. remote Ollama with faster model).
      */
     completeDistill(prompt: string, maxTokens?: number): Promise<string>;
     /**

package/dist/llm.js

@@ -24,6 +24,8 @@ exports.resolveLlmConfig = resolveLlmConfig;
 exports.resolveLlmConfigForCC = resolveLlmConfigForCC;
 exports.findClaudeBinary = findClaudeBinary;
 exports.claudeCliConfig = claudeCliConfig;
+exports.probeOllama = probeOllama;
+exports.preferOllamaForBatch = preferOllamaForBatch;
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const node_os_1 = require("node:os");
@@ -348,6 +350,55 @@ function claudeCliConfig(claudePath) {
         provider: "claude-cli",
     };
 }
+/**
+ * Check if a local Ollama instance is reachable and has models loaded.
+ * Returns the model name if available, null otherwise.
+ */
+async function probeOllama(baseUrl = "http://localhost:11434") {
+    try {
+        const resp = await fetch(`${baseUrl}/api/ps`, {
+            signal: AbortSignal.timeout(3000),
+        });
+        if (!resp.ok)
+            return null;
+        const data = (await resp.json());
+        if (data.models && data.models.length > 0) {
+            return data.models[0].name;
+        }
+        // No model loaded — check if any are available
+        const tagsResp = await fetch(`${baseUrl}/api/tags`, {
+            signal: AbortSignal.timeout(3000),
+        });
+        if (!tagsResp.ok)
+            return null;
+        const tags = (await tagsResp.json());
+        return tags.models?.[0]?.name ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * For batch operations (nightly pipeline), prefer Ollama when available.
+ * Claude CLI has strict rate limits that kill batch distillation.
+ * Falls back to the provided config if Ollama is unreachable.
+ */
+async function preferOllamaForBatch(resolved, ollamaBaseUrl = "http://localhost:11434") {
+    // Only override claude-cli (which has rate limits)
+    if (resolved.provider !== "claude-cli")
+        return resolved;
+    const model = await probeOllama(ollamaBaseUrl);
+    if (!model)
+        return resolved;
+    return {
+        ...resolved,
+        baseUrl: ollamaBaseUrl,
+        apiKey: "",
+        model,
+        reflectModel: resolved.reflectModel ?? model,
+        provider: "ollama",
+    };
+}
 // ---------------------------------------------------------------------------
 // LLM Client class
 // ---------------------------------------------------------------------------
@@ -401,8 +452,12 @@ class LlmClient {
     }
     /**
      * Distillation-tier completion (session knowledge extraction).
+     * Routes to distillBaseUrl/distillProvider if configured (e.g. remote Ollama with faster model).
      */
     async completeDistill(prompt, maxTokens = 2048) {
+        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.complete(this.config.distillModel ?? this.config.model, prompt, maxTokens, 900_000);
     }
     /**

package/dist/mcp-server.js

@@ -273,10 +273,15 @@ async function startServer(options = {}) {
             reflectModel: savedConfig?.reflectModel,
         });
     }
-    // Apply optional distillModel (e.g. larger local model for session extraction)
+    // 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;
+    }
     // Apply separate reflect endpoint if configured (e.g. remote Ollama with larger model)
     if (savedConfig?.reflectBaseUrl) {
         llmConfig.reflectBaseUrl = savedConfig.reflectBaseUrl;
@@ -284,11 +289,13 @@ async function startServer(options = {}) {
         llmConfig.reflectProvider = savedConfig.reflectProvider ?? llmConfig.provider;
     }
     llm = new llm_js_1.LlmClient(llmConfig);
-    const distillInfo = llmConfig.distillModel ? `, distill: ${llmConfig.distillModel}` : "";
+    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}, reflect: ${reflectInfo}`);
+    console.log(`[hicortex] LLM fast: ${llmConfig.provider}/${llmConfig.model}${distillInfo ? `, distill: ${distillInfo}` : ""}, reflect: ${reflectInfo}`);
     // License: read from options, config file, or env var
     const licenseKey = options.licenseKey
         ?? savedConfig?.licenseKey

package/dist/nightly.js

@@ -147,18 +147,30 @@ async function runNightly(options = {}) {
                 reflectModel: savedConfig?.reflectModel,
             });
         }
-        // Apply distillModel and reflect overrides from config
+        // Apply distill and reflect overrides from config
         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;
+        }
         if (savedConfig?.reflectBaseUrl) {
             llmConfig.reflectBaseUrl = savedConfig.reflectBaseUrl;
             llmConfig.reflectApiKey = savedConfig.reflectApiKey ?? llmConfig.apiKey;
             llmConfig.reflectProvider = savedConfig.reflectProvider ?? llmConfig.provider;
         }
+        // Auto-detect Ollama for batch distillation (claude-cli has rate limits)
+        llmConfig = await (0, llm_js_1.preferOllamaForBatch)(llmConfig);
+        if (llmConfig.provider === "ollama") {
+            console.log(`[hicortex] Auto-detected local Ollama (${llmConfig.model}) — using for batch distillation`);
+        }
         const llm = new llm_js_1.LlmClient(llmConfig);
-        const distillInfo = llmConfig.distillModel ? `, distill: ${llmConfig.distillModel}` : "";
-        console.log(`[hicortex] LLM: ${llmConfig.provider}/${llmConfig.model}${distillInfo}`);
+        const distillInfo = llmConfig.distillBaseUrl
+            ? `${llmConfig.distillProvider}/${llmConfig.distillModel}@${llmConfig.distillBaseUrl}`
+            : llmConfig.distillModel ?? "";
+        console.log(`[hicortex] LLM: ${llmConfig.provider}/${llmConfig.model}${distillInfo ? `, distill: ${distillInfo}` : ""}`);
         // Step 1: Read new CC transcripts
         const since = readLastRun();
         console.log(`[hicortex] Reading CC transcripts since ${since.toISOString()}`);
@@ -171,6 +183,8 @@ async function runNightly(options = {}) {
         // Step 2: Distill each session
         let memoriesIngested = 0;
         const features = (0, license_js_1.getFeatures)(stateDir);
+        // Detect safe chunk size based on model context window
+        const chunkSize = await (0, distiller_js_1.detectChunkSize)(llmConfig.provider, llmConfig.distillModel ?? llmConfig.model, llmConfig.baseUrl);
         for (const batch of batches) {
             const transcript = (0, distiller_js_1.extractConversationText)(batch.entries);
             if (transcript.length < 200) {
@@ -189,7 +203,7 @@ async function runNightly(options = {}) {
                 break;
             }
             try {
-                const entries = await (0, distiller_js_1.distillSession)(llm, transcript, batch.projectName, batch.date);
+                const entries = await (0, distiller_js_1.distillSession)(llm, transcript, batch.projectName, batch.date, chunkSize);
                 for (const entry of entries) {
                     try {
                         const embedding = await (0, embedder_js_1.embed)(entry);
@@ -288,8 +302,23 @@ async function runClientNightly(config, dryRun) {
     if (config.distillModel) {
         llmConfig.distillModel = config.distillModel;
     }
+    if (config.distillBaseUrl) {
+        llmConfig.distillBaseUrl = config.distillBaseUrl;
+        llmConfig.distillApiKey = config.distillApiKey ?? llmConfig.apiKey;
+        llmConfig.distillProvider = config.distillProvider ?? llmConfig.provider;
+    }
+    // Auto-detect Ollama for batch distillation when claude-cli was resolved (fallback)
+    llmConfig = await (0, llm_js_1.preferOllamaForBatch)(llmConfig);
+    if (llmConfig.provider === "ollama" && !config.distillBaseUrl) {
+        console.log(`[hicortex] Auto-detected local Ollama (${llmConfig.model}) — using for batch distillation`);
+    }
     const llm = new llm_js_1.LlmClient(llmConfig);
-    console.log(`[hicortex] LLM: ${llmConfig.provider}/${llmConfig.distillModel ?? llmConfig.model}`);
+    const distillInfo = llmConfig.distillBaseUrl
+        ? `${llmConfig.distillProvider}/${llmConfig.distillModel}@${llmConfig.distillBaseUrl}`
+        : llmConfig.distillModel ?? "";
+    console.log(`[hicortex] LLM: ${llmConfig.provider}/${llmConfig.model}${distillInfo ? `, distill: ${distillInfo}` : ""}`);
+    // Detect safe chunk size based on model context window
+    const chunkSize = await (0, distiller_js_1.detectChunkSize)(llmConfig.provider, llmConfig.distillModel ?? llmConfig.model, llmConfig.baseUrl);
     // Read new CC transcripts
     const since = readLastRun();
     console.log(`[hicortex] Reading CC transcripts since ${since.toISOString()}`);
@@ -316,7 +345,7 @@ async function runClientNightly(config, dryRun) {
             continue;
         }
         try {
-            const entries = await (0, distiller_js_1.distillSession)(llm, transcript, batch.projectName, batch.date);
+            const entries = await (0, distiller_js_1.distillSession)(llm, transcript, batch.projectName, batch.date, chunkSize);
             if (entries.length === 0) {
                 console.log(`[hicortex]     → No memories extracted`);
                 continue;

package/dist/prompts.js

@@ -134,6 +134,8 @@ RULES:
   tool configurations, API discoveries, project milestones
 - PRIORITIZE Corrections & Rejections — these are high-value signals for learning
   what the user does NOT want. Even a single "no" or style correction is worth extracting.
+- Strong language or profanity from the user is a high-intensity signal — it indicates
+  the correction matters deeply. Note the intensity in the extraction.
 - PRIVACY CLASSIFICATION (one of):
   - PUBLIC: general tech knowledge, open-source patterns, publicly available info
   - WORK: project-specific decisions, architecture choices, client/business context

package/dist/status.js

@@ -112,9 +112,43 @@ async function runStatus() {
     const lastRunPath = (0, node_path_1.join)(HICORTEX_HOME, "nightly-last-run.txt");
     try {
         const ts = (0, node_fs_1.readFileSync)(lastRunPath, "utf-8").trim();
-        console.log(`  Last run:   ${ts}`);
+        const lastRun = new Date(ts);
+        if (isNaN(lastRun.getTime())) {
+            console.log(`  Last run:   ${ts} (invalid timestamp)`);
+        }
+        else {
+            const STALE_THRESHOLD_HOURS = 30;
+            const ageHours = Math.round((Date.now() - lastRun.getTime()) / (60 * 60 * 1000));
+            const ageStr = ageHours < 1 ? "just now" : ageHours < 24 ? `${ageHours}h ago` : `${Math.round(ageHours / 24)}d ago`;
+            console.log(`  Last run:   ${ts} (${ageStr})`);
+            // Show staleness warning if missed a night
+            if (ageHours > STALE_THRESHOLD_HOURS) {
+                console.log(`  ⚠ Nightly pipeline hasn't run in ${ageHours}h. Check: hicortex nightly --dry-run`);
+            }
+        }
     }
     catch {
-        console.log("  Last run:   never");
+        console.log("  Last run:   never (run: hicortex nightly)");
+    }
+    // Distillation stats (if DB exists)
+    if (dbExists) {
+        const TOP_SOURCES_LIMIT = 5;
+        try {
+            const { initDb } = await import("./db.js");
+            const db2 = initDb(dbPath);
+            // Count memories by source
+            const rows = db2.prepare(`SELECT source_agent, COUNT(*) as cnt FROM memories GROUP BY source_agent ORDER BY cnt DESC LIMIT ${TOP_SOURCES_LIMIT}`).all();
+            if (rows.length > 0) {
+                console.log("  Sources:");
+                for (const r of rows) {
+                    const agent = r.source_agent || "unknown";
+                    console.log(`    ${agent}: ${r.cnt}`);
+                }
+            }
+            db2.close();
+        }
+        catch (err) {
+            console.log(`  Sources:    (error: ${err instanceof Error ? err.message : String(err)})`);
+        }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gamaze/hicortex",
-  "version": "0.4.1",
+  "version": "0.4.2",
   "description": "Human-like memory for self-improving AI agents. Automatic capturing, nightly reflection, and cross-agent learning. Works with Claude Code and OpenClaw.",
   "main": "dist/index.js",
   "bin": {
@@ -11,6 +11,17 @@
       "./dist/index.js"
     ]
   },
+  "keywords": [
+    "mcp-server",
+    "memory",
+    "ai-agents",
+    "agent-memory",
+    "self-improving",
+    "claude-code",
+    "openclaw",
+    "vector-search",
+    "nightly-distillation"
+  ],
   "types": "dist/index.d.ts",
   "files": [
     "dist/",