@gamaze/hicortex 0.5.2 → 0.6.0

package/dist/claude-md.js

@@ -51,6 +51,7 @@ const node_os_1 = require("node:os");
 const storage = __importStar(require("./storage.js"));
 const features_js_1 = require("./features.js");
 const extensions_js_1 = require("./extensions.js");
+const state_js_1 = require("./state.js");
 const START_MARKER = "<!-- HICORTEX-LEARNINGS:START -->";
 const END_MARKER = "<!-- HICORTEX-LEARNINGS:END -->";
 const DEFAULT_CLAUDE_MD = (0, node_path_1.join)((0, node_os_1.homedir)(), ".claude", "CLAUDE.md");
@@ -63,11 +64,15 @@ async function injectLessons(db, options = {}) {
     const claudeMdPath = options.claudeMdPath ?? DEFAULT_CLAUDE_MD;
     // Determine limits based on license
     const maxLessons = (0, features_js_1.lessonsLimit)();
+    // Load MODULE_INDEX from state for domain-aware selection
+    const state = (0, state_js_1.loadState)(options.stateDir);
+    const moduleIndex = state.moduleIndex;
     // --- Lessons ---
     const lessons = storage.getLessons(db, 30, options.project);
     const selected = await (0, extensions_js_1.getLessonSelector)().select(lessons, {
         maxLessons,
         project: options.project,
+        moduleIndex,
     });
     const lessonLines = selected.map((l) => {
         const titleMatch = l.content.match(/## Lesson: (.+)/);
@@ -78,7 +83,8 @@ async function injectLessons(db, options = {}) {
         return `- ${title}${meta ? ` (${meta})` : ""}`;
     });
     // --- Memory Index ---
-    const projectIndex = buildProjectIndex(db);
+    const tokenBudget = readModuleIndexTokenBudget();
+    const indexLines = buildModuleIndex(db, tokenBudget, moduleIndex);
     const totalCount = storage.countMemories(db);
     const lessonCount = lessons.length;
     const sourceCount = countSources(db);
@@ -102,9 +108,9 @@ async function injectLessons(db, options = {}) {
         blockParts.push(...projectContext);
     }
     // Memory index
-    if (projectIndex.length > 0) {
+    if (indexLines.length > 0) {
         blockParts.push("", "### Memory Index");
-        blockParts.push(projectIndex.join(" | "));
+        blockParts.push(...indexLines);
         blockParts.push(`${totalCount} memories, ${lessonCount} lessons, ${sourceCount} agents. Search with \`hicortex_search\`.`);
     }
     blockParts.push(END_MARKER);
@@ -136,17 +142,57 @@ async function injectLessons(db, options = {}) {
     (0, node_fs_1.writeFileSync)(claudeMdPath, content);
     return { lessonsCount: selected.length, path: claudeMdPath };
 }
+const DEFAULT_MODULE_INDEX_TOKEN_BUDGET = 500;
+// BPE tokenizers average 3.5-4.5 chars/token for English prose. 4 is conservative.
+const CHARS_PER_TOKEN = 4;
 /**
- * Build compact project index: "hicortex: 18 | boat: 24 | health: 45"
+ * Read moduleIndexTokenBudget from config.json. Defaults to 500.
  */
-function buildProjectIndex(db) {
+function readModuleIndexTokenBudget() {
+    try {
+        const configPath = (0, node_path_1.join)((0, node_os_1.homedir)(), ".hicortex", "config.json");
+        const config = JSON.parse((0, node_fs_1.readFileSync)(configPath, "utf-8"));
+        return typeof config.moduleIndexTokenBudget === "number"
+            ? config.moduleIndexTokenBudget
+            : DEFAULT_MODULE_INDEX_TOKEN_BUDGET;
+    }
+    catch {
+        return DEFAULT_MODULE_INDEX_TOKEN_BUDGET;
+    }
+}
+/**
+ * Build structured MODULE_INDEX block for injection.
+ * Uses domain-grouped format if MODULE_INDEX is available,
+ * falls back to flat "project: count" format otherwise.
+ */
+function buildModuleIndex(db, tokenBudget, moduleIndex) {
+    if (moduleIndex && moduleIndex.domains.length > 0) {
+        const charBudget = tokenBudget * CHARS_PER_TOKEN;
+        let charCount = 0;
+        const lines = [];
+        for (const domain of moduleIndex.domains) {
+            const kwStr = domain.keywords.length > 0
+                ? `: ${domain.keywords.join(", ")}`
+                : "";
+            const domainLine = `${domain.name} (${domain.memoryCount} memories, ${domain.lessonCount} lessons)${kwStr}`;
+            const projectLine = `  ${domain.projects.join(" | ")}`;
+            const blockChars = domainLine.length + projectLine.length + 2; // +2 for newlines
+            if (charCount + blockChars > charBudget && lines.length > 0)
+                break;
+            lines.push(domainLine);
+            lines.push(projectLine);
+            charCount += blockChars;
+        }
+        return lines;
+    }
+    // Fallback: flat project index (OSS default)
     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}`);
+        return [rows.map((r) => `${r.project}: ${r.cnt}`).join(" | ")];
     }
     catch {
         return [];

package/dist/consolidate.d.ts

@@ -24,7 +24,7 @@ export declare function parseJsonLenient<T>(text: string, fallback: T): T;
 /**
  * Run the full consolidation pipeline. Returns a structured report.
  */
-export declare function runConsolidation(db: Database.Database, llm: LlmClient, embedFn: EmbedFn, dryRun?: boolean, skipReflection?: boolean): Promise<ConsolidationReport>;
+export declare function runConsolidation(db: Database.Database, llm: LlmClient, embedFn: EmbedFn, dryRun?: boolean, skipReflection?: boolean, stateDir?: string): Promise<ConsolidationReport>;
 /**
  * Calculate milliseconds until the next occurrence of a given hour (local time).
  */

package/dist/consolidate.js

@@ -46,6 +46,7 @@ exports.scheduleConsolidation = scheduleConsolidation;
 const retrieval_js_1 = require("./retrieval.js");
 const storage = __importStar(require("./storage.js"));
 const prompts_js_1 = require("./prompts.js");
+const node_crypto_1 = require("node:crypto");
 const features_js_1 = require("./features.js");
 const state_js_1 = require("./state.js");
 // Default config constants (matching Python config.py)
@@ -273,14 +274,42 @@ async function stageReflection(db, memories, llm, budget, embedFn, dryRun) {
                     break;
                 }
                 const embedding = await embedFn(content);
-                storage.insertMemory(db, content, embedding, {
-                    sourceAgent: "hicortex/reflection",
-                    project,
-                    memoryType: "lesson",
-                    baseStrength: baseStrength[severity] ?? 0.8,
-                    privacy: "WORK",
+                // Contradiction check: find semantically similar existing lessons.
+                // If a very similar lesson exists, ask the LLM whether the new one
+                // contradicts it. If yes, suppress the new lesson to prevent the
+                // "false coherence" failure mode (wrong lessons reinforcing themselves).
+                const similarLessons = storage.vectorSearch(db, embedding, 3)
+                    .filter((n) => {
+                    const sim = 1.0 - n.distance;
+                    return sim > 0.80 && n.memory_type === "lesson";
                 });
-                generated++;
+                let contradicted = false;
+                if (similarLessons.length > 0 && budget.use("contradiction_check")) {
+                    const existingText = similarLessons[0].content.slice(0, 300);
+                    const newText = content.slice(0, 300);
+                    try {
+                        const verdict = await llm.completeFast(`Two lessons from an AI memory system. Do they CONTRADICT each other (opposite advice on the same topic)?\n\n` +
+                            `EXISTING: ${existingText}\n\nNEW: ${newText}\n\n` +
+                            `Answer ONLY "yes" or "no". If the new lesson updates/refines the existing one (not contradicts), answer "no".`, 16);
+                        if (verdict.toLowerCase().trim().startsWith("yes")) {
+                            contradicted = true;
+                            console.log(`[hicortex] Lesson suppressed (contradicts existing): "${lessonText.slice(0, 80)}"`);
+                        }
+                    }
+                    catch {
+                        // LLM call failed — don't suppress, store the lesson
+                    }
+                }
+                if (!contradicted) {
+                    storage.insertMemory(db, content, embedding, {
+                        sourceAgent: "hicortex/reflection",
+                        project,
+                        memoryType: "lesson",
+                        baseStrength: baseStrength[severity] ?? 0.8,
+                        privacy: "WORK",
+                    });
+                    generated++;
+                }
             }
             catch {
                 // Failed to store lesson
@@ -293,6 +322,136 @@ async function stageReflection(db, memories, llm, budget, embedFn, dryRun) {
     }
 }
 // ---------------------------------------------------------------------------
+// Stage 2.7: Domain Curation (MODULE_INDEX)
+// ---------------------------------------------------------------------------
+async function stageDomainCuration(db, llm, budget, dryRun, stateDir) {
+    // Gather all projects with memory and lesson counts
+    const projectRows = db
+        .prepare(`SELECT project, COUNT(*) as cnt FROM memories
+       WHERE project IS NOT NULL GROUP BY project ORDER BY cnt DESC`)
+        .all();
+    if (projectRows.length === 0) {
+        return { curated: false, domains: 0, reason: "no_projects" };
+    }
+    const lessonRows = db
+        .prepare(`SELECT project, COUNT(*) as cnt FROM memories
+       WHERE project IS NOT NULL AND memory_type = 'lesson'
+       GROUP BY project`)
+        .all();
+    const lessonsByProject = new Map(lessonRows.map((r) => [r.project, r.cnt]));
+    // Cache check: skip if project set unchanged
+    const sortedNames = projectRows.map((r) => r.project).sort();
+    const projectSetHash = (0, node_crypto_1.createHash)("sha256")
+        .update(JSON.stringify(sortedNames))
+        .digest("hex");
+    const state = (0, state_js_1.loadState)(stateDir);
+    if (state.moduleIndex?.projectSetHash === projectSetHash) {
+        return { curated: false, domains: state.moduleIndex.domains.length, reason: "project_set_unchanged" };
+    }
+    const totalMemories = projectRows.reduce((s, r) => s + r.cnt, 0);
+    const totalLessons = lessonRows.reduce((s, r) => s + r.cnt, 0);
+    let domains;
+    if (!(0, features_js_1.isPro)()) {
+        // OSS fallback: each project is its own domain
+        domains = projectRows.map((r) => ({
+            name: r.project,
+            projects: [r.project],
+            memoryCount: r.cnt,
+            lessonCount: lessonsByProject.get(r.project) ?? 0,
+            keywords: [],
+        }));
+    }
+    else {
+        // Pro: LLM-curated domains
+        if (!budget.use("domain_curation")) {
+            return { curated: false, domains: 0, reason: "budget_exhausted" };
+        }
+        const projectLines = projectRows
+            .map((r) => `${r.project}: ${r.cnt} / ${lessonsByProject.get(r.project) ?? 0}`)
+            .join("\n");
+        try {
+            const raw = await llm.completeFast((0, prompts_js_1.domainCuration)(projectLines), 1024);
+            const parsed = parseJsonLenient(raw, []);
+            if (!Array.isArray(parsed) || parsed.length === 0) {
+                console.warn("[hicortex] Domain curation: LLM returned empty/invalid response, using fallback");
+                domains = projectRows.map((r) => ({
+                    name: r.project,
+                    projects: [r.project],
+                    memoryCount: r.cnt,
+                    lessonCount: lessonsByProject.get(r.project) ?? 0,
+                    keywords: [],
+                }));
+            }
+            else {
+                domains = [];
+                const assigned = new Set();
+                const knownProjects = new Set(sortedNames);
+                for (const item of parsed) {
+                    if (typeof item !== "object" || item === null)
+                        continue;
+                    const d = item;
+                    const name = String(d.name ?? "");
+                    const projects = Array.isArray(d.projects)
+                        ? d.projects.map(String).filter((p) => !assigned.has(p) && knownProjects.has(p))
+                        : [];
+                    const keywords = Array.isArray(d.keywords)
+                        ? d.keywords.map(String).slice(0, 5)
+                        : [];
+                    if (!name || projects.length === 0)
+                        continue;
+                    for (const p of projects)
+                        assigned.add(p);
+                    const memoryCount = projects.reduce((s, p) => s + (projectRows.find((r) => r.project === p)?.cnt ?? 0), 0);
+                    const lessonCount = projects.reduce((s, p) => s + (lessonsByProject.get(p) ?? 0), 0);
+                    domains.push({ name, projects, memoryCount, lessonCount, keywords });
+                }
+                // Catch unassigned projects
+                const unassigned = sortedNames.filter((p) => !assigned.has(p));
+                if (unassigned.length > 0) {
+                    const memoryCount = unassigned.reduce((s, p) => s + (projectRows.find((r) => r.project === p)?.cnt ?? 0), 0);
+                    const lessonCount = unassigned.reduce((s, p) => s + (lessonsByProject.get(p) ?? 0), 0);
+                    domains.push({ name: "Miscellaneous", projects: unassigned, memoryCount, lessonCount, keywords: [] });
+                }
+                // Sort by memoryCount desc
+                domains.sort((a, b) => b.memoryCount - a.memoryCount);
+            }
+        }
+        catch (err) {
+            console.warn(`[hicortex] Domain curation LLM failed: ${err instanceof Error ? err.message : String(err)}`);
+            domains = projectRows.map((r) => ({
+                name: r.project,
+                projects: [r.project],
+                memoryCount: r.cnt,
+                lessonCount: lessonsByProject.get(r.project) ?? 0,
+                keywords: [],
+            }));
+        }
+    }
+    const moduleIndex = {
+        domains,
+        projectSetHash,
+        curatedAt: new Date().toISOString(),
+        totalMemories,
+        totalLessons,
+    };
+    if (!dryRun) {
+        // Persist MODULE_INDEX to state.json
+        (0, state_js_1.updateState)((s) => { s.moduleIndex = moduleIndex; }, stateDir);
+        // Batch-update domain column on memories
+        const updateStmt = db.prepare("UPDATE memories SET domain = ? WHERE project = ?");
+        const tx = db.transaction(() => {
+            for (const domain of domains) {
+                for (const project of domain.projects) {
+                    updateStmt.run(domain.name, project);
+                }
+            }
+        });
+        tx();
+    }
+    console.log(`[hicortex] Domain curation: ${domains.length} domains from ${projectRows.length} projects`);
+    return { curated: true, domains: domains.length };
+}
+// ---------------------------------------------------------------------------
 // Stage 3: Link Discovery (vector similarity auto-link)
 // ---------------------------------------------------------------------------
 async function stageLinks(db, memories, embedFn, dryRun) {
@@ -388,7 +547,7 @@ function stageDecayPrune(db, dryRun) {
 /**
  * Run the full consolidation pipeline. Returns a structured report.
  */
-async function runConsolidation(db, llm, embedFn, dryRun = false, skipReflection = false) {
+async function runConsolidation(db, llm, embedFn, dryRun = false, skipReflection = false, stateDir) {
     const start = new Date();
     const report = {
         started_at: start.toISOString(),
@@ -434,6 +593,8 @@ async function runConsolidation(db, llm, embedFn, dryRun = false, skipReflection
         else {
             report.stages.reflection = await stageReflection(db, precheck.newMemories, llm, budget, embedFn, dryRun);
         }
+        // Stage 2.7: Domain Curation
+        report.stages.domain_curation = await stageDomainCuration(db, llm, budget, dryRun, stateDir);
         // Stage 3: Link Discovery
         report.stages.links = await stageLinks(db, precheck.newMemories, embedFn, dryRun);
         // Stage 4: Decay & Prune
@@ -448,7 +609,7 @@ async function runConsolidation(db, llm, embedFn, dryRun = false, skipReflection
         (0, state_js_1.updateState)((s) => {
             s.lastConsolidated = new Date().toISOString();
             return s;
-        });
+        }, stateDir);
     }
     report.budget = budget.summary();
     report.completed_at = new Date().toISOString();

package/dist/db.js

@@ -216,6 +216,16 @@ const MIGRATIONS = [
             }
         },
     },
+    {
+        version: 3,
+        name: "add_domain",
+        up: (db) => {
+            if (!hasColumn(db, "memories", "domain")) {
+                db.exec("ALTER TABLE memories ADD COLUMN domain TEXT");
+            }
+            db.exec("CREATE INDEX IF NOT EXISTS idx_memories_domain ON memories(domain)");
+        },
+    },
 ];
 /**
  * Run all pending migrations against the database.

package/dist/distiller.d.ts

@@ -4,6 +4,7 @@
  * not from filesystem scanning.
  */
 import type { LlmClient } from "./llm.js";
+import { type RedactionConfig } from "./redact.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)
@@ -14,9 +15,13 @@ import type { LlmClient } from "./llm.js";
  */
 export declare function detectChunkSize(provider: string, model: string, baseUrl?: string): Promise<number>;
 /**
- * Convert OpenClaw hook messages to a filtered transcript string.
+ * Convert session messages to a filtered transcript string.
+ * Handles OC hook format, CC JSONL, and Pi JSONL.
+ *
+ * If redactionConfig is provided (or defaults to enabled), secrets and PII
+ * are scrubbed from the final text BEFORE it reaches any LLM or storage.
  */
-export declare function extractConversationText(messages: unknown[]): string;
+export declare function extractConversationText(messages: unknown[], redactionConfig?: RedactionConfig): string;
 /**
  * Send filtered conversation to LLM for knowledge extraction.
  * For large transcripts, chunks into segments to avoid overwhelming small models.

package/dist/distiller.js

@@ -9,6 +9,7 @@ exports.detectChunkSize = detectChunkSize;
 exports.extractConversationText = extractConversationText;
 exports.distillSession = distillSession;
 const prompts_js_1 = require("./prompts.js");
+const redact_js_1 = require("./redact.js");
 const MAX_TRANSCRIPT_CHARS = 80_000;
 const MIN_CONVERSATION_CHARS = 200;
 // Chunk size limits by model parameter count (for local/CPU inference)
@@ -162,9 +163,13 @@ function cleanMessageContent(text) {
     return text.trim();
 }
 /**
- * Convert OpenClaw hook messages to a filtered transcript string.
+ * Convert session messages to a filtered transcript string.
+ * Handles OC hook format, CC JSONL, and Pi JSONL.
+ *
+ * If redactionConfig is provided (or defaults to enabled), secrets and PII
+ * are scrubbed from the final text BEFORE it reaches any LLM or storage.
  */
-function extractConversationText(messages) {
+function extractConversationText(messages, redactionConfig) {
     const parts = [];
     for (const msg of messages) {
         if (typeof msg !== "object" || msg === null)
@@ -196,7 +201,15 @@ function extractConversationText(messages) {
         const role = msgRole === "user" ? "USER" : "ASSISTANT";
         parts.push(`${role}: ${text}`);
     }
-    return parts.join("\n\n");
+    let result = parts.join("\n\n");
+    // Redact secrets and PII before the text reaches any LLM or storage.
+    // This is the last step — after all cleaning/filtering but before return.
+    const { text: redacted, count } = (0, redact_js_1.redact)(result, redactionConfig);
+    if (count > 0) {
+        console.log(`[hicortex] Redacted ${count} secret(s) from transcript`);
+    }
+    result = redacted;
+    return result;
 }
 /**
  * Send filtered conversation to LLM for knowledge extraction.

package/dist/extensions.d.ts

@@ -28,6 +28,7 @@
  *   - LessonValidator — speculative; no validation exists today. Will add
  *     when the first Pro use case demands it.
  */
+import type { ModuleIndex } from "./types.js";
 /**
  * Minimum fields a lesson must have for the selector to work.
  *
@@ -57,6 +58,8 @@ export interface LessonSelectorContext {
     agentId?: string;
     /** Optional: current task description, for relevance scoring (Pro). */
     currentTask?: string;
+    /** MODULE_INDEX for domain-aware lesson selection (Pro). */
+    moduleIndex?: ModuleIndex;
 }
 export interface LessonSelector {
     /**

package/dist/mcp-server.js

@@ -224,6 +224,25 @@ function createMcpServer() {
             return { content: [{ type: "text", text: `Lessons fetch failed: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
         }
     });
+    // -- hicortex_index --
+    server.tool("hicortex_index", "Get the knowledge domain index — shows what topics and projects are stored in memory, grouped by domain.", {}, async () => {
+        const state = (0, state_js_1.loadState)(stateDir);
+        const moduleIndex = state.moduleIndex;
+        if (moduleIndex && moduleIndex.domains.length > 0) {
+            const text = moduleIndex.domains.map((d) => `**${d.name}** (${d.memoryCount} memories, ${d.lessonCount} lessons)\n` +
+                `  Projects: ${d.projects.join(", ")}` +
+                (d.keywords.length > 0 ? `\n  Keywords: ${d.keywords.join(", ")}` : "")).join("\n\n");
+            return { content: [{ type: "text", text }] };
+        }
+        // Fallback: flat project counts
+        if (!db)
+            return { content: [{ type: "text", text: "No index available" }] };
+        const rows = db.prepare("SELECT project, COUNT(*) as cnt FROM memories WHERE project IS NOT NULL GROUP BY project ORDER BY cnt DESC LIMIT 20").all();
+        const text = rows.length > 0
+            ? rows.map((r) => `${r.project}: ${r.cnt} memories`).join("\n")
+            : "No memories yet.";
+        return { content: [{ type: "text", text }] };
+    });
     return server;
 }
 // ---------------------------------------------------------------------------
@@ -385,6 +404,7 @@ async function startServer(options = {}) {
                 .all();
             const sourceCount = db.prepare("SELECT COUNT(DISTINCT source_agent) as cnt FROM memories").get().cnt;
             const lessonCount = lessons.length;
+            const state = (0, state_js_1.loadState)();
             res.json({
                 lessons: lessons.map(l => ({
                     content: l.content,
@@ -398,6 +418,7 @@ async function startServer(options = {}) {
                     sourceCount,
                     projects: projects.map(p => ({ name: p.project, count: p.cnt })),
                 },
+                moduleIndex: state.moduleIndex ?? null,
             });
         }
         catch (err) {

package/dist/nightly.js

@@ -559,7 +559,9 @@ async function injectLessonsFromServer(serverUrl, authToken) {
     }
     const data = await resp.json();
     const maxLessons = (0, features_js_1.lessonsLimit)();
-    const selected = await (0, extensions_js_1.getLessonSelector)().select(data.lessons, { maxLessons });
+    // Use moduleIndex from server response, fall back to local state
+    const moduleIndex = data.moduleIndex ?? (0, state_js_1.loadState)().moduleIndex;
+    const selected = await (0, extensions_js_1.getLessonSelector)().select(data.lessons, { maxLessons, moduleIndex });
     // Format lessons
     const lessonLines = selected.map((l) => {
         const titleMatch = l.content.match(/## Lesson: (.+)/);
@@ -569,8 +571,19 @@ async function injectLessonsFromServer(serverUrl, authToken) {
         const meta = [severityMatch?.[1], typeMatch?.[1]].filter(Boolean).join(", ");
         return `- ${title}${meta ? ` (${meta})` : ""}`;
     });
-    // Format project index
-    const projectIndex = data.index.projects.map(p => `${p.name}: ${p.count}`);
+    // Format module/project index
+    let indexLines;
+    if (moduleIndex && moduleIndex.domains.length > 0) {
+        indexLines = [];
+        for (const domain of moduleIndex.domains) {
+            const kwStr = domain.keywords.length > 0 ? `: ${domain.keywords.join(", ")}` : "";
+            indexLines.push(`${domain.name} (${domain.memoryCount} memories, ${domain.lessonCount} lessons)${kwStr}`);
+            indexLines.push(`  ${domain.projects.join(" | ")}`);
+        }
+    }
+    else {
+        indexLines = [data.index.projects.map(p => `${p.name}: ${p.count}`).join(" | ")];
+    }
     // Build block
     const START_MARKER = "<!-- HICORTEX-LEARNINGS:START -->";
     const END_MARKER = "<!-- HICORTEX-LEARNINGS:END -->";
@@ -586,9 +599,9 @@ async function injectLessonsFromServer(serverUrl, authToken) {
         blockParts.push("- Save important decisions with `hicortex_ingest`");
         blockParts.push("- Lessons will appear here after the first nightly run");
     }
-    if (projectIndex.length > 0) {
+    if (indexLines.length > 0) {
         blockParts.push("", "### Memory Index");
-        blockParts.push(projectIndex.join(" | "));
+        blockParts.push(...indexLines);
         blockParts.push(`${data.index.total} memories, ${data.index.lessonCount} lessons, ${data.index.sourceCount} agents. Search with \`hicortex_search\`.`);
     }
     blockParts.push(END_MARKER);

package/dist/prompts.d.ts

@@ -14,3 +14,8 @@ export declare function reflection(memoriesBlock: string, recentLessons?: string
  * Distillation prompt. Extracts knowledge from a session transcript.
  */
 export declare function distillation(projectName: string, date: string, transcript: string): string;
+/**
+ * Domain curation prompt. Groups projects into knowledge domains.
+ * Used during consolidation (Pro only, one call per nightly when projects change).
+ */
+export declare function domainCuration(projectLines: string): string;

package/dist/prompts.js

@@ -7,6 +7,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.importanceScoring = importanceScoring;
 exports.reflection = reflection;
 exports.distillation = distillation;
+exports.domainCuration = domainCuration;
 /**
  * Importance scoring prompt. Takes a {memories_block} with indexed memories.
  */
@@ -145,3 +146,26 @@ RULES:
 - If nothing worth extracting, output ONLY: "NO_EXTRACT"
 `;
 }
+/**
+ * Domain curation prompt. Groups projects into knowledge domains.
+ * Used during consolidation (Pro only, one call per nightly when projects change).
+ */
+function domainCuration(projectLines) {
+    return `You are a knowledge organizer. Given project names with memory and lesson counts, group them into logical knowledge DOMAINS (3-8 domains).
+
+PROJECTS (name: memories / lessons):
+${projectLines}
+
+For each domain, output a JSON object:
+- "name": Short domain label (2-4 words, Title Case)
+- "projects": Array of project names belonging to this domain
+- "keywords": 3-5 representative keywords for this domain
+
+Rules:
+- Every project must appear in exactly one domain
+- Projects with only 1-2 memories can go in a "Miscellaneous" domain
+- Prefer fewer domains over many tiny ones
+- Domain names should be descriptive and distinct
+
+Respond with ONLY a JSON array. No explanations.`;
+}

package/dist/redact.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Pre-ingestion redaction — scrubs secrets and PII from transcript text
+ * BEFORE it reaches the distillation LLM or storage.
+ *
+ * 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.
+ *   - 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.
+ *
+ * Default patterns cover common API key formats, bearer tokens, absolute
+ * paths, and generic key=value secrets. Users can add custom patterns via
+ * config.json "redaction.extraPatterns".
+ *
+ * The replacement is always [REDACTED] (or configurable). This preserves
+ * the structure of the text so the LLM can still extract useful knowledge
+ * from the surrounding context.
+ */
+/** Result of a redaction pass. */
+export interface RedactionResult {
+    /** The redacted text. */
+    text: string;
+    /** Number of individual redactions applied. */
+    count: number;
+}
+/** Configuration for redaction, read from config.json. */
+export interface RedactionConfig {
+    /** Master switch. Default: true. */
+    enabled?: boolean;
+    /** Additional regex patterns (strings, compiled to RegExp with 'g' flag). */
+    extraPatterns?: string[];
+    /** Replacement string. Default: "[REDACTED]". */
+    replacement?: string;
+}
+/**
+ * Redact secrets and PII from text.
+ *
+ * @param text The raw transcript text to redact
+ * @param config Optional configuration (extra patterns, replacement string)
+ * @returns The redacted text and count of redactions applied
+ */
+export declare function redact(text: string, config?: RedactionConfig): RedactionResult;

package/dist/redact.js

@@ -0,0 +1,101 @@
+"use strict";
+/**
+ * Pre-ingestion redaction — scrubs secrets and PII from transcript text
+ * BEFORE it reaches the distillation LLM or storage.
+ *
+ * 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.
+ *   - 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.
+ *
+ * Default patterns cover common API key formats, bearer tokens, absolute
+ * paths, and generic key=value secrets. Users can add custom patterns via
+ * config.json "redaction.extraPatterns".
+ *
+ * The replacement is always [REDACTED] (or configurable). This preserves
+ * the structure of the text so the LLM can still extract useful knowledge
+ * from the surrounding context.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.redact = redact;
+/**
+ * Default redaction patterns. Each targets a specific class of secret.
+ * Order matters: more specific patterns should come first to avoid
+ * partial matches by generic patterns.
+ */
+const DEFAULT_PATTERNS = [
+    // Anthropic API keys: sk-ant-api03-...
+    { name: "anthropic_key", pattern: /sk-ant-[a-zA-Z0-9\-_]{20,}/g },
+    // OpenAI API keys: sk-proj-... or sk-...
+    { name: "openai_key", pattern: /sk-(?:proj-)?[a-zA-Z0-9]{20,}/g },
+    // Hicortex license keys: hctx-... (case-insensitive — keys could appear uppercased in logs)
+    { name: "hicortex_key", pattern: /hctx-[a-f0-9]{16}/gi },
+    // GitHub Personal Access Tokens: ghp_...
+    { name: "github_pat", pattern: /ghp_[a-zA-Z0-9]{36}/g },
+    // GitHub OAuth tokens: gho_...
+    { name: "github_oauth", pattern: /gho_[a-zA-Z0-9]{36}/g },
+    // Google API keys: AIza...
+    { name: "google_key", pattern: /AIza[a-zA-Z0-9_\-]{35}/g },
+    // AWS access keys: AKIA...
+    { name: "aws_key", pattern: /AKIA[A-Z0-9]{16}/g },
+    // Stripe live/test keys: sk_live_..., sk_test_...
+    { name: "stripe_key", pattern: /sk_(?:live|test)_[a-zA-Z0-9]{20,}/g },
+    // Bearer tokens in headers (case-insensitive — headers are case-insensitive)
+    { name: "bearer_token", pattern: /[Bb]earer\s+[a-zA-Z0-9._\-]{20,}/g },
+    // Generic secret assignments: password=..., secret_key=..., token: ...
+    // Matches key=value and key: value patterns with common secret key names.
+    // The key name can have underscores/hyphens and optional suffixes (SECRET_KEY, api-key, etc.)
+    // Negative lookahead for [REDACTED] prevents double-counting when a prior pattern
+    // already replaced the value (e.g., bearer_token fires, then generic_secret sees
+    // "token: [REDACTED]" and would otherwise match again).
+    { name: "generic_secret", pattern: /(?:password|secret(?:[_-]?key)?|token|api[_-]?key|private[_-]?key|access[_-]?key)\s*[:=]\s*["']?(?!\[REDACTED\])[^\s"']{8,}["']?/gi },
+    // Absolute macOS paths: /Users/<username>/...
+    // Negative lookbehind avoids matching URL paths like https://api.example.com/Users/list
+    { name: "macos_path", pattern: /(?<![:/])\/Users\/[a-zA-Z0-9._-]+/g },
+    // Absolute Linux home paths: /home/<username>/...
+    // Same lookbehind to avoid URL false positives
+    { name: "linux_path", pattern: /(?<![:/])\/home\/[a-zA-Z0-9._-]+/g },
+];
+/**
+ * Redact secrets and PII from text.
+ *
+ * @param text The raw transcript text to redact
+ * @param config Optional configuration (extra patterns, replacement string)
+ * @returns The redacted text and count of redactions applied
+ */
+function redact(text, config) {
+    if (config?.enabled === false)
+        return { text, count: 0 };
+    const replacement = config?.replacement ?? "[REDACTED]";
+    let count = 0;
+    let result = text;
+    // Apply default patterns
+    for (const { pattern } of DEFAULT_PATTERNS) {
+        // Reset lastIndex for global regexes (they're stateful)
+        pattern.lastIndex = 0;
+        result = result.replace(pattern, () => {
+            count++;
+            return replacement;
+        });
+    }
+    // Apply user-configured extra patterns
+    if (config?.extraPatterns) {
+        for (const patternStr of config.extraPatterns) {
+            try {
+                const re = new RegExp(patternStr, "g");
+                result = result.replace(re, () => {
+                    count++;
+                    return replacement;
+                });
+            }
+            catch {
+                // Invalid regex — skip silently (don't crash the pipeline)
+            }
+        }
+    }
+    return { text: result, count };
+}

package/dist/state.d.ts

@@ -16,7 +16,7 @@
  * Note: ~/.hicortex/config.json is intentionally NOT merged here. Config is
  * user-edited and tracked separately from machine state.
  */
-import type { LicenseInfo } from "./types.js";
+import type { LicenseInfo, ModuleIndex } from "./types.js";
 /** Persisted tier information — reflects the last successful validation. */
 export interface PersistedTier {
     /** Tier name from the validation API response. */
@@ -35,6 +35,8 @@ export interface HicortexState {
     tier?: PersistedTier;
     /** Anonymous telemetry UUID — generated once, never linked to personal info. */
     telemetryId?: string;
+    /** Cached MODULE_INDEX from domain curation (generated during consolidation). */
+    moduleIndex?: ModuleIndex;
 }
 /**
  * Load the state file. Returns an empty state if the file is missing

package/dist/storage.js

@@ -75,6 +75,7 @@ const ALLOWED_UPDATE_FIELDS = new Set([
     "source_agent",
     "source_session",
     "project",
+    "domain",
     "privacy",
     "memory_type",
     "updated_at",

package/dist/types.d.ts

@@ -14,6 +14,7 @@ export interface Memory {
     source_agent: string;
     source_session: string | null;
     project: string | null;
+    domain: string | null;
     privacy: "PUBLIC" | "WORK" | "PERSONAL" | "SENSITIVE";
     memory_type: "episode" | "lesson" | "fact" | "decision";
     updated_at: string | null;
@@ -59,10 +60,16 @@ export interface ConsolidationReport {
         };
         reflection?: {
             lessons_generated: number;
+            contradictions_suppressed?: number;
             failed?: boolean;
             skipped?: boolean;
             reason?: string;
         };
+        domain_curation?: {
+            curated: boolean;
+            domains: number;
+            reason?: string;
+        };
         links?: {
             auto_linked: number;
             failed: number;
@@ -104,6 +111,22 @@ export interface LicenseInfo {
     email?: string;
     expires_at?: string;
 }
+/** A knowledge domain grouping related projects. */
+export interface ModuleDomain {
+    name: string;
+    projects: string[];
+    memoryCount: number;
+    lessonCount: number;
+    keywords: string[];
+}
+/** Auto-generated knowledge routing index, cached in state.json. */
+export interface ModuleIndex {
+    domains: ModuleDomain[];
+    projectSetHash: string;
+    curatedAt: string;
+    totalMemories: number;
+    totalLessons: number;
+}
 /** Options for inserting a memory. */
 export interface InsertMemoryOptions {
     sourceAgent?: string;

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "hicortex",
   "name": "Hicortex — Long-term Memory That Learns",
   "description": "Your agents remember past decisions, avoid repeated mistakes, and get smarter every day. Nightly reflection generates actionable lessons that automatically update agent behavior.",
-  "version": "0.5.2",
+  "version": "0.6.0",
   "kind": "lifecycle",
   "skills": ["./skills/hicortex-memory", "./skills/hicortex-learn", "./skills/hicortex-activate"],
   "configSchema": {

package/package.json

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