@gamaze/hicortex 0.3.16 → 0.4.0

package/dist/nightly.js

@@ -96,8 +96,14 @@ function writeLastRun() {
 }
 async function runNightly(options = {}) {
     const dryRun = options.dryRun ?? false;
-    const dbPath = (0, db_js_1.resolveDbPath)(options.dbPath);
     const stateDir = options.stateDir ?? HICORTEX_HOME;
+    // Check mode: client or server
+    const savedConfig = readNightlyConfig(stateDir);
+    if (savedConfig?.mode === "client") {
+        await runClientNightly(savedConfig, dryRun);
+        return;
+    }
+    const dbPath = (0, db_js_1.resolveDbPath)(options.dbPath);
     console.log(`[hicortex] Nightly pipeline starting${dryRun ? " (dry run)" : ""}`);
     console.log(`[hicortex] DB: ${dbPath}`);
     // Init DB
@@ -116,18 +122,43 @@ async function runNightly(options = {}) {
             }
             else {
                 console.warn("[hicortex] claude-cli configured but binary not found, falling back");
-                llmConfig = (0, llm_js_1.resolveLlmConfigForCC)();
+                llmConfig = (0, llm_js_1.resolveLlmConfigForCC)({
+                    llmBaseUrl: savedConfig?.llmBaseUrl,
+                    llmApiKey: savedConfig?.llmApiKey,
+                    llmModel: savedConfig?.llmModel,
+                    reflectModel: savedConfig?.reflectModel,
+                });
             }
         }
+        else if (savedConfig?.llmBackend === "ollama") {
+            llmConfig = {
+                baseUrl: savedConfig.llmBaseUrl ?? "http://localhost:11434",
+                apiKey: "",
+                model: savedConfig.llmModel ?? "qwen3.5:4b",
+                reflectModel: savedConfig.reflectModel ?? savedConfig.llmModel ?? "qwen3.5:4b",
+                provider: "ollama",
+            };
+        }
         else {
             llmConfig = (0, llm_js_1.resolveLlmConfigForCC)({
                 llmBaseUrl: savedConfig?.llmBaseUrl,
                 llmApiKey: savedConfig?.llmApiKey,
                 llmModel: savedConfig?.llmModel,
+                reflectModel: savedConfig?.reflectModel,
             });
         }
+        // Apply distillModel and reflect overrides from config
+        if (savedConfig?.distillModel) {
+            llmConfig.distillModel = savedConfig.distillModel;
+        }
+        if (savedConfig?.reflectBaseUrl) {
+            llmConfig.reflectBaseUrl = savedConfig.reflectBaseUrl;
+            llmConfig.reflectApiKey = savedConfig.reflectApiKey ?? llmConfig.apiKey;
+            llmConfig.reflectProvider = savedConfig.reflectProvider ?? llmConfig.provider;
+        }
         const llm = new llm_js_1.LlmClient(llmConfig);
-        console.log(`[hicortex] LLM: ${llmConfig.provider}/${llmConfig.model}`);
+        const distillInfo = llmConfig.distillModel ? `, distill: ${llmConfig.distillModel}` : "";
+        console.log(`[hicortex] LLM: ${llmConfig.provider}/${llmConfig.model}${distillInfo}`);
         // Step 1: Read new CC transcripts
         const since = readLastRun();
         console.log(`[hicortex] Reading CC transcripts since ${since.toISOString()}`);
@@ -206,3 +237,141 @@ async function runNightly(options = {}) {
         db.close();
     }
 }
+// ---------------------------------------------------------------------------
+// Client Mode Nightly — distill locally, POST to remote server
+// ---------------------------------------------------------------------------
+async function runClientNightly(config, dryRun) {
+    const serverUrl = config.serverUrl.replace(/\/+$/, "");
+    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`);
+    }
+    catch (err) {
+        console.error(`[hicortex] Server unreachable at ${serverUrl}: ${err instanceof Error ? err.message : String(err)}`);
+        console.error(`[hicortex] Aborting. Will retry next run.`);
+        return; // Don't update last-run so we retry
+    }
+    // Init LLM for local distillation
+    let llmConfig;
+    if (config.llmBackend === "claude-cli") {
+        const claudePath = (0, llm_js_1.findClaudeBinary)();
+        if (claudePath) {
+            llmConfig = (0, llm_js_1.claudeCliConfig)(claudePath);
+        }
+        else {
+            llmConfig = (0, llm_js_1.resolveLlmConfigForCC)();
+        }
+    }
+    else if (config.llmBackend === "ollama") {
+        llmConfig = {
+            baseUrl: config.llmBaseUrl ?? "http://localhost:11434",
+            apiKey: "",
+            model: config.llmModel ?? "qwen3.5:4b",
+            reflectModel: config.reflectModel ?? config.llmModel ?? "qwen3.5:4b",
+            provider: "ollama",
+        };
+    }
+    else {
+        llmConfig = (0, llm_js_1.resolveLlmConfigForCC)({
+            llmBaseUrl: config.llmBaseUrl,
+            llmApiKey: config.llmApiKey,
+            llmModel: config.llmModel,
+        });
+    }
+    if (config.distillModel) {
+        llmConfig.distillModel = config.distillModel;
+    }
+    const llm = new llm_js_1.LlmClient(llmConfig);
+    console.log(`[hicortex] LLM: ${llmConfig.provider}/${llmConfig.distillModel ?? llmConfig.model}`);
+    // Read new CC transcripts
+    const since = readLastRun();
+    console.log(`[hicortex] Reading CC transcripts since ${since.toISOString()}`);
+    const batches = (0, transcript_reader_js_1.readCcTranscripts)(since);
+    console.log(`[hicortex] Found ${batches.length} new session(s)`);
+    if (batches.length === 0) {
+        console.log(`[hicortex] Nothing to distill.`);
+        if (!dryRun)
+            writeLastRun();
+        return;
+    }
+    // Distill each session and POST to server
+    let memoriesIngested = 0;
+    let sessionsSent = 0;
+    for (const batch of batches) {
+        const transcript = (0, distiller_js_1.extractConversationText)(batch.entries);
+        if (transcript.length < 200) {
+            console.log(`[hicortex]   Skip ${batch.sessionId.slice(0, 8)} (${batch.projectName}): too short`);
+            continue;
+        }
+        console.log(`[hicortex]   Distilling ${batch.sessionId.slice(0, 8)} (${batch.projectName}, ${batch.date})`);
+        if (dryRun) {
+            console.log(`[hicortex]     [dry-run] Would distill ${transcript.length} chars`);
+            continue;
+        }
+        try {
+            const entries = await (0, distiller_js_1.distillSession)(llm, transcript, batch.projectName, batch.date);
+            if (entries.length === 0) {
+                console.log(`[hicortex]     → No memories extracted`);
+                continue;
+            }
+            // POST each extracted memory to the server
+            let sessionCount = 0;
+            for (const entry of entries) {
+                const resp = await fetch(`${serverUrl}/ingest`, {
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/json",
+                        ...(authToken ? { "Authorization": `Bearer ${authToken}` } : {}),
+                    },
+                    body: JSON.stringify({
+                        content: entry,
+                        source_agent: `claude-code/${batch.projectName}`,
+                        project: batch.projectName,
+                        memory_type: "episode",
+                        privacy: "WORK",
+                        source_session: batch.sessionId,
+                        session_date: batch.date,
+                    }),
+                    signal: AbortSignal.timeout(30_000),
+                });
+                const result = await resp.json();
+                if (resp.status === 201) {
+                    sessionCount++;
+                    memoriesIngested++;
+                }
+                else if (result.skipped) {
+                    console.log(`[hicortex]     → Already ingested (${result.existing_count} existing)`);
+                    break;
+                }
+                else if (resp.status === 401) {
+                    console.error(`[hicortex]     Auth failed. Check authToken in ~/.hicortex/config.json`);
+                    return;
+                }
+                else if (resp.status === 429) {
+                    console.log(`[hicortex]     Server memory limit reached.`);
+                    return;
+                }
+                else {
+                    console.error(`[hicortex]     Ingest failed (${resp.status}): ${result.error}`);
+                }
+            }
+            if (sessionCount > 0) {
+                sessionsSent++;
+                console.log(`[hicortex]     → ${sessionCount} memories sent to server`);
+            }
+        }
+        catch (err) {
+            console.error(`[hicortex]     Failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    if (!dryRun)
+        writeLastRun();
+    console.log(`[hicortex] Client nightly complete: ${memoriesIngested} memories from ${sessionsSent} sessions → ${serverUrl}`);
+}

package/dist/prompts.d.ts

@@ -9,7 +9,7 @@ export declare function importanceScoring(memoriesBlock: string): string;
 /**
  * Reflection prompt. Takes a {memories_block} with today's memories.
  */
-export declare function reflection(memoriesBlock: string): string;
+export declare function reflection(memoriesBlock: string, recentLessons?: string): string;
 /**
  * Distillation prompt. Extracts knowledge from a session transcript.
  */

package/dist/prompts.js

@@ -32,33 +32,61 @@ No explanations. Just the JSON array.`;
 /**
  * Reflection prompt. Takes a {memories_block} with today's memories.
  */
-function reflection(memoriesBlock) {
-    return `You are a self-improvement analyst for a multi-agent AI system. Review today's memories and extract 1-3 actionable lessons.
+function reflection(memoriesBlock, recentLessons) {
+    const recentSection = recentLessons
+        ? `\nRECENT LESSONS (already generated — do NOT duplicate, but DO escalate if patterns recur):\n${recentLessons}\n`
+        : "";
+    return `You are a learning analyst for a multi-agent AI system. Review today's memories and extract actionable lessons from BOTH successes and failures.
 
-Quality over quantity. One genuine insight that prevents a future mistake is worth more than five restatements of what happened. Most days, 1-2 lessons is ideal. An empty array is fine if nothing warrants a lesson.
+Like human learning: we grow fastest when we reinforce what works AND correct what doesn't. A system that only learns from mistakes becomes overly cautious. A system that only learns from successes never improves. The combination multiplies.
 
-Prefer GLOBAL lessons (applicable across all projects and agents) over project-specific ones. Only mark a lesson as project-specific if it truly cannot generalize.
-
-Good lesson: "When modifying template files processed by sed, always verify ALL substitution targets by diffing the output — partial fixes cause silent failures on other deployments"
-Bad lesson: "The deploy script had a bug" (restatement, not actionable)
+Quality over quantity. 1-3 lessons is typical. An empty array [] is the CORRECT response when memories show routine competent work without noteworthy patterns, surprises, or friction. Do not manufacture lessons from nothing.
 
+LESSON TYPES:
+- "reinforce": An approach or strategy that worked well — repeat and spread it
+- "correct": A mistake, gap, or near-miss that should be avoided
+- "principle": A general insight derived from either success or failure
+${recentSection}
 TODAY'S MEMORIES:
 ${memoriesBlock}
 
+EXAMPLES:
+Good reinforce: "Bundling related changes into a single PR with clear narrative gets faster approval — apply for all refactors"
+Good reinforce: "When presenting multi-scenario analysis, show assumptions side-by-side so stakeholders evaluate trade-offs rather than reacting to isolated worst-cases"
+Good correct: "Always verify ALL substitution targets by diffing output — partial fixes cause silent failures"
+Good principle: "Gather evidence from logs before forming hypotheses — evidence-first debugging resolved issues 3x faster today"
+Bad lesson: "The deploy script had a bug" (restatement, not actionable)
+
 For each lesson, output a JSON object:
 - "lesson": Concise, actionable rule in imperative voice
-- "project": "global" unless genuinely project-specific
+- "type": "reinforce" | "correct" | "principle"
+- "project": "global" unless genuinely project-specific (project-specific lessons are still valuable)
 - "severity": "critical" | "important" | "minor"
 - "confidence": "high" | "medium" | "low"
-- "source_pattern": What triggered this (1 sentence)
+- "source_pattern": What triggered this (1 sentence, no personal data)
 
-Confidence:
-- "high": Pattern across multiple events, or clear mistake with obvious fix. Safe to auto-inject into agent instructions.
+Severity guide:
+- "critical": Near-misses that could have caused data loss or security breach, even if caught in time. Also: recurring patterns that keep appearing despite prior corrections.
+- "important": Clear cause-effect, likely to recur. Worth sharing across agents.
+- "minor": Useful optimization, single incident.
+
+Confidence guide:
+- "high": Pattern across multiple events, or clear cause-effect. Safe to auto-inject into agent instructions.
 - "medium": Single incident but likely to recur. Store but don't auto-propagate.
 - "low": Speculative. Store for retrieval only.
 
-Focus on: process gaps, repeated friction, silent failures, user corrections to agent behavior, cross-agent patterns.
-Skip: trivial actions, already-documented rules, one-off events.
+Focus on:
+- SUCCESSES: effective strategies, approaches the user validated, patterns that saved time, clean solutions
+- FAILURES: process gaps, repeated friction, silent failures, user corrections
+- OMISSIONS: things that should have been done but weren't (missing tests, unchecked code paths, forgotten follow-ups)
+- NEAR-MISSES: problems caught before damage — these deserve critical severity
+- CONTRADICTIONS: cases where something appeared to work but didn't, or agents reached opposite conclusions
+- CROSS-AGENT PATTERNS: same issue or success across different agents — especially high-value
+- PROCESS FEEDBACK: user feedback about the agent's approach/behavior, not just its output
+
+Privacy: Never include personal data (names, health, finances, credentials) in lesson text. Abstract to the process level.
+
+Skip: isolated trivial actions, already-documented rules. However, if multiple small successes form a consistent pattern of quality, extract that pattern as a reinforcement.
 
 Respond with a JSON array. Empty array [] is a valid response.`;
 }

package/dist/storage.js

@@ -77,21 +77,22 @@ const ALLOWED_UPDATE_FIELDS = new Set([
     "project",
     "privacy",
     "memory_type",
+    "updated_at",
 ]);
 /**
  * Update specific fields on a memory.
  */
 function updateMemory(db, memoryId, fields) {
-    const keys = Object.keys(fields);
-    if (keys.length === 0)
-        return;
+    // Auto-set updated_at timestamp
+    const fieldsWithTimestamp = { ...fields, updated_at: new Date().toISOString() };
+    const keys = Object.keys(fieldsWithTimestamp);
     for (const k of keys) {
         if (!ALLOWED_UPDATE_FIELDS.has(k)) {
             throw new Error(`Cannot update field: ${k}`);
         }
     }
     const setClause = keys.map((k) => `"${k}" = ?`).join(", ");
-    const values = keys.map((k) => fields[k]);
+    const values = keys.map((k) => fieldsWithTimestamp[k]);
     values.push(memoryId);
     db.prepare(`UPDATE memories SET ${setClause} WHERE id = ?`).run(...values);
 }

package/dist/types.d.ts

@@ -16,6 +16,7 @@ export interface Memory {
     project: string | null;
     privacy: "PUBLIC" | "WORK" | "PERSONAL" | "SENSITIVE";
     memory_type: "episode" | "lesson" | "fact" | "decision";
+    updated_at: string | null;
 }
 /** A link between two memories. */
 export interface MemoryLink {
@@ -98,6 +99,7 @@ export interface LicenseInfo {
         vectorSearch: boolean;
         maxMemories: number;
         crossAgent: boolean;
+        remoteIngest?: boolean;
     };
     email?: string;
     expires_at?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gamaze/hicortex",
-  "version": "0.3.16",
+  "version": "0.4.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": {
@@ -35,6 +35,7 @@
     "node": ">=18"
   },
   "license": "UNLICENSED",
+  "homepage": "https://hicortex.gamaze.com",
   "repository": {
     "type": "git",
     "url": "https://github.com/mha33/hicortex.git",