@gamaze/hicortex 0.5.0 → 0.5.2

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): Promise<ConsolidationReport>;
+export declare function runConsolidation(db: Database.Database, llm: LlmClient, embedFn: EmbedFn, dryRun?: boolean, skipReflection?: boolean): Promise<ConsolidationReport>;
 /**
  * Calculate milliseconds until the next occurrence of a given hour (local time).
  */

package/dist/consolidate.js

@@ -388,7 +388,7 @@ function stageDecayPrune(db, dryRun) {
 /**
  * Run the full consolidation pipeline. Returns a structured report.
  */
-async function runConsolidation(db, llm, embedFn, dryRun = false) {
+async function runConsolidation(db, llm, embedFn, dryRun = false, skipReflection = false) {
     const start = new Date();
     const report = {
         started_at: start.toISOString(),
@@ -424,7 +424,16 @@ async function runConsolidation(db, llm, embedFn, dryRun = false) {
         // Stage 2: Importance Scoring
         report.stages.importance = await stageImportance(db, scoreMemories, llm, budget, dryRun);
         // Stage 2.5: Reflection
-        report.stages.reflection = await stageReflection(db, precheck.newMemories, llm, budget, embedFn, dryRun);
+        if (skipReflection) {
+            report.stages.reflection = {
+                lessons_generated: 0,
+                skipped: true,
+                reason: "reflect_endpoint_offline",
+            };
+        }
+        else {
+            report.stages.reflection = await stageReflection(db, precheck.newMemories, llm, budget, embedFn, dryRun);
+        }
         // Stage 3: Link Discovery
         report.stages.links = await stageLinks(db, precheck.newMemories, embedFn, dryRun);
         // Stage 4: Decay & Prune

package/dist/nightly.js

@@ -47,6 +47,11 @@ exports.runNightly = runNightly;
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const node_os_1 = require("node:os");
+let VERSION = "0.0.0";
+try {
+    VERSION = JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(__dirname, "..", "package.json"), "utf-8")).version;
+}
+catch { }
 const db_js_1 = require("./db.js");
 const llm_js_1 = require("./llm.js");
 const embedder_js_1 = require("./embedder.js");
@@ -59,6 +64,7 @@ const claude_md_js_1 = require("./claude-md.js");
 const features_js_1 = require("./features.js");
 const extensions_js_1 = require("./extensions.js");
 const state_js_1 = require("./state.js");
+const telemetry_js_1 = require("./telemetry.js");
 const HICORTEX_HOME = (0, node_path_1.join)((0, node_os_1.homedir)(), ".hicortex");
 function readNightlyConfig(stateDir) {
     try {
@@ -270,8 +276,24 @@ async function runNightly(options = {}) {
         console.log(`[hicortex] Distillation complete: ${memoriesIngested} new memories`);
         // Step 3: Consolidation
         if (!dryRun) {
+            // Pre-flight health check for the reflect endpoint.
+            // If reflectBaseUrl points to a remote Ollama and it's down (MBP offline),
+            // skip reflection entirely instead of waiting through 3 retries (~3.5 min).
+            // Scoring + linking + decay still run (they use the local model or don't need LLM).
+            let skipReflection = false;
+            if (llmConfig.reflectBaseUrl && (llmConfig.reflectProvider ?? llmConfig.provider) === "ollama") {
+                const reflectModel = llmConfig.reflectModel ?? llmConfig.model;
+                const health = await (0, llm_js_1.probeOllamaModel)(llmConfig.reflectBaseUrl, reflectModel);
+                if (!health.ok) {
+                    const reason = health.reason === "unreachable"
+                        ? `reflect endpoint unreachable (${llmConfig.reflectBaseUrl})`
+                        : `reflect model not loaded (${reflectModel} missing on ${llmConfig.reflectBaseUrl})`;
+                    console.warn(`[hicortex] ${reason} — skipping reflection, scoring + linking will still run`);
+                    skipReflection = true;
+                }
+            }
             console.log(`[hicortex] Running consolidation...`);
-            const report = await (0, consolidate_js_1.runConsolidation)(db, llm, embedder_js_1.embed, dryRun);
+            const report = await (0, consolidate_js_1.runConsolidation)(db, llm, embedder_js_1.embed, dryRun, skipReflection);
             console.log(`[hicortex] Consolidation ${report.status} in ${report.elapsed_seconds}s` +
                 (report.stages.reflection ? ` (${report.stages.reflection.lessons_generated} lessons)` : ""));
         }
@@ -299,6 +321,22 @@ async function runNightly(options = {}) {
             }
         }
         console.log(`[hicortex] Nightly pipeline complete.`);
+        // Step 6: Anonymous telemetry (fire-and-forget, opt-out via config)
+        if (!dryRun && (0, telemetry_js_1.isTelemetryEnabled)(savedConfig)) {
+            const agentType = piBatches.length > 0 && ccBatches.length > 0 ? "mixed"
+                : piBatches.length > 0 ? "pi"
+                    : "cc";
+            await (0, telemetry_js_1.sendTelemetry)({
+                id: (0, telemetry_js_1.getTelemetryId)(stateDir),
+                v: VERSION,
+                mode: "server",
+                agent: agentType,
+                mem: storage.countMemories(db),
+                lessons: storage.getLessons(db, 365).length,
+                sessions: batches.length,
+                ok: !hadTransientFailure,
+            });
+        }
     }
     finally {
         db.close();
@@ -492,6 +530,19 @@ async function runClientNightly(config, dryRun) {
         }
     }
     console.log(`[hicortex] Client nightly complete: ${memoriesIngested} memories from ${sessionsSent} sessions → ${serverUrl}`);
+    // Anonymous telemetry (fire-and-forget, opt-out via config)
+    if (!dryRun && (0, telemetry_js_1.isTelemetryEnabled)(config)) {
+        await (0, telemetry_js_1.sendTelemetry)({
+            id: (0, telemetry_js_1.getTelemetryId)(HICORTEX_HOME),
+            v: VERSION,
+            mode: "client",
+            agent: "cc", // client mode is always CC-originated currently
+            mem: memoriesIngested,
+            lessons: 0, // client doesn't know lesson count
+            sessions: batches.length,
+            ok: !hadTransientFailure,
+        });
+    }
 }
 /**
  * Fetch lessons + memory index from server and inject into CLAUDE.md.

package/dist/state.d.ts

@@ -33,6 +33,8 @@ export interface HicortexState {
     lastConsolidated?: string;
     /** Last-known license tier (replaces tier.json + license-validated.txt). */
     tier?: PersistedTier;
+    /** Anonymous telemetry UUID — generated once, never linked to personal info. */
+    telemetryId?: string;
 }
 /**
  * Load the state file. Returns an empty state if the file is missing

package/dist/telemetry.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Anonymous telemetry — sends aggregate stats after each nightly run.
+ *
+ * What's sent (8 fields, all aggregate):
+ *   id       — random UUID, generated once on first run, stored in state.json
+ *   v        — package version
+ *   mode     — server or client
+ *   agent    — cc, pi, oc, or mixed (detected from session sources)
+ *   mem      — total memory count
+ *   lessons  — total lesson count
+ *   sessions — sessions distilled this run
+ *   ok       — nightly succeeded (true/false)
+ *
+ * What's NOT sent:
+ *   No personal data, no session content, no file paths, no IPs stored.
+ *
+ * Opt-out:
+ *   Set "telemetry": false in ~/.hicortex/config.json
+ *   OR set HICORTEX_TELEMETRY=off in the environment
+ *
+ * The ping is fire-and-forget with a 5s timeout. If it fails, nothing
+ * happens — the nightly result is unaffected.
+ */
+export interface TelemetryPayload {
+    id: string;
+    v: string;
+    mode: string;
+    agent: string;
+    mem: number;
+    lessons: number;
+    sessions: number;
+    ok: boolean;
+}
+/**
+ * Check if telemetry is enabled. Disabled by:
+ *   - config.telemetry === false
+ *   - HICORTEX_TELEMETRY env var set to "off", "false", or "0"
+ */
+export declare function isTelemetryEnabled(config: Record<string, unknown> | null): boolean;
+/**
+ * Get or create the anonymous telemetry ID.
+ * Generated once, stored in state.json, never linked to any personal info.
+ */
+export declare function getTelemetryId(stateDir: string): string;
+/**
+ * Send anonymous telemetry. Fire-and-forget — failures are silently ignored.
+ */
+export declare function sendTelemetry(payload: TelemetryPayload, serverUrl?: string): Promise<void>;

package/dist/telemetry.js

@@ -0,0 +1,77 @@
+"use strict";
+/**
+ * Anonymous telemetry — sends aggregate stats after each nightly run.
+ *
+ * What's sent (8 fields, all aggregate):
+ *   id       — random UUID, generated once on first run, stored in state.json
+ *   v        — package version
+ *   mode     — server or client
+ *   agent    — cc, pi, oc, or mixed (detected from session sources)
+ *   mem      — total memory count
+ *   lessons  — total lesson count
+ *   sessions — sessions distilled this run
+ *   ok       — nightly succeeded (true/false)
+ *
+ * What's NOT sent:
+ *   No personal data, no session content, no file paths, no IPs stored.
+ *
+ * Opt-out:
+ *   Set "telemetry": false in ~/.hicortex/config.json
+ *   OR set HICORTEX_TELEMETRY=off in the environment
+ *
+ * The ping is fire-and-forget with a 5s timeout. If it fails, nothing
+ * happens — the nightly result is unaffected.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTelemetryEnabled = isTelemetryEnabled;
+exports.getTelemetryId = getTelemetryId;
+exports.sendTelemetry = sendTelemetry;
+const node_crypto_1 = require("node:crypto");
+const state_js_1 = require("./state.js");
+const TELEMETRY_URL = "https://hicortex.gamaze.com/api/telemetry";
+/**
+ * Check if telemetry is enabled. Disabled by:
+ *   - config.telemetry === false
+ *   - HICORTEX_TELEMETRY env var set to "off", "false", or "0"
+ */
+function isTelemetryEnabled(config) {
+    // Config override
+    if (config?.telemetry === false)
+        return false;
+    // Env var override
+    const env = process.env.HICORTEX_TELEMETRY?.toLowerCase();
+    if (env === "off" || env === "false" || env === "0")
+        return false;
+    return true;
+}
+/**
+ * Get or create the anonymous telemetry ID.
+ * Generated once, stored in state.json, never linked to any personal info.
+ */
+function getTelemetryId(stateDir) {
+    const state = (0, state_js_1.loadState)(stateDir);
+    if (state.telemetryId)
+        return state.telemetryId;
+    const id = (0, node_crypto_1.randomUUID)();
+    (0, state_js_1.updateState)((s) => {
+        s.telemetryId = id;
+        return s;
+    }, stateDir);
+    return id;
+}
+/**
+ * Send anonymous telemetry. Fire-and-forget — failures are silently ignored.
+ */
+async function sendTelemetry(payload, serverUrl = TELEMETRY_URL) {
+    try {
+        await fetch(serverUrl, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(payload),
+            signal: AbortSignal.timeout(5_000),
+        });
+    }
+    catch {
+        // Silently ignore — telemetry must never affect the nightly result
+    }
+}

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.0",
+  "version": "0.5.2",
   "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.0",
+  "version": "0.5.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": {