@gamaze/hicortex 0.2.0

package/dist/index.js

@@ -0,0 +1,557 @@
+"use strict";
+/**
+ * Hicortex OpenClaw Plugin — Long-term Memory That Learns.
+ *
+ * Pure in-process plugin: no sidecar, no HTTP. Uses better-sqlite3 + sqlite-vec
+ * for storage, @huggingface/transformers for embeddings, and multi-provider LLM
+ * for distillation and consolidation.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_path_1 = require("node:path");
+const node_fs_1 = require("node:fs");
+const db_js_1 = require("./db.js");
+const license_js_1 = require("./license.js");
+const llm_js_1 = require("./llm.js");
+const node_fs_2 = require("node:fs");
+const node_os_1 = require("node:os");
+const embedder_js_1 = require("./embedder.js");
+const storage = __importStar(require("./storage.js"));
+const retrieval = __importStar(require("./retrieval.js"));
+const distiller_js_1 = require("./distiller.js");
+const consolidate_js_1 = require("./consolidate.js");
+// ---------------------------------------------------------------------------
+// Module state — initialized in registerService.start()
+// ---------------------------------------------------------------------------
+let db = null;
+let llm = null;
+let cancelConsolidation = null;
+let stateDir = "";
+// ---------------------------------------------------------------------------
+// Plugin export
+// ---------------------------------------------------------------------------
+exports.default = {
+    id: "hicortex",
+    name: "Hicortex \u2014 Long-term Memory That Learns",
+    kind: "lifecycle",
+    register(api) {
+        // -----------------------------------------------------------------------
+        // Background service: init DB, embedder, LLM, consolidation timer
+        // -----------------------------------------------------------------------
+        api.registerService({
+            id: "hicortex-service",
+            async start(ctx) {
+                const config = (ctx.config ?? {});
+                stateDir = ctx.stateDir ?? (0, node_path_1.join)(process.env.HOME ?? "~", ".hicortex");
+                const log = ctx.logger
+                    ? (msg) => ctx.logger.info(msg)
+                    : console.log;
+                // Ensure data directory exists
+                const dataDir = (0, node_path_1.join)(stateDir, "data");
+                (0, node_fs_1.mkdirSync)(dataDir, { recursive: true });
+                // Initialize database
+                const dbPath = config.dbPath ?? (0, node_path_1.join)(dataDir, "hicortex.db");
+                log(`[hicortex] Initializing database at ${dbPath}`);
+                db = (0, db_js_1.initDb)(dbPath);
+                // Auto-configure LLM: resolve → test → persist
+                const llmConfig = await autoConfigureLlm(config, log);
+                llm = new llm_js_1.LlmClient(llmConfig);
+                log(`[hicortex] LLM: ${llmConfig.provider}/${llmConfig.model} ` +
+                    `(reflect: ${llmConfig.reflectModel})`);
+                // License check (non-blocking)
+                (0, license_js_1.validateLicense)(config.licenseKey, stateDir).catch((err) => log(`[hicortex] License validation failed: ${err}`));
+                // Schedule nightly consolidation
+                const consolidateHour = config.consolidateHour ?? 2;
+                cancelConsolidation = (0, consolidate_js_1.scheduleConsolidation)(db, llm, embedder_js_1.embed, consolidateHour);
+                // Seed the bootstrap lesson on first run
+                await injectSeedLesson(db, log);
+                // Auto-add tools to tools.allow if using a restrictive profile
+                ensureToolsAllowed(log);
+                // Log stats
+                const stats = (0, db_js_1.getStats)(db, dbPath);
+                log(`[hicortex] Ready: ${stats.memories} memories, ${stats.links} links, ` +
+                    `${Math.round(stats.db_size_bytes / 1024)} KB`);
+            },
+            async stop() {
+                if (cancelConsolidation) {
+                    cancelConsolidation();
+                    cancelConsolidation = null;
+                }
+                if (db) {
+                    db.close();
+                    db = null;
+                }
+                llm = null;
+            },
+        });
+        // -----------------------------------------------------------------------
+        // Hook: before_agent_start — inject lessons into agent context
+        // -----------------------------------------------------------------------
+        api.on("before_agent_start", async (event, ctx) => {
+            if (!db)
+                return {};
+            try {
+                const lessons = storage.getLessons(db, 7, ctx.project);
+                if (lessons.length === 0)
+                    return {};
+                const maxFeatures = (0, license_js_1.getFeatures)(stateDir);
+                const maxLessons = maxFeatures.maxMemories === -1 ? 20 : 10;
+                const formatted = lessons.slice(0, maxLessons).map((l) => {
+                    // Extract just the lesson text from the structured content
+                    const match = l.content.match(/## Lesson: (.+)/);
+                    return match ? `- ${match[1]}` : `- ${l.content.slice(0, 200)}`;
+                });
+                let context = `\n\n## Hicortex Lessons (auto-injected from long-term memory)\n` +
+                    `These are actionable lessons learned from past sessions:\n\n` +
+                    formatted.join("\n") +
+                    "\n";
+                // Daily friendly reminder when at memory cap
+                const memCount = storage.countMemories(db);
+                if (maxFeatures.maxMemories > 0 && memCount >= maxFeatures.maxMemories) {
+                    context +=
+                        `\n---\nHicortex free tier: ${maxFeatures.maxMemories} memories stored. ` +
+                            `New memories can no longer be saved, and your agent has stopped learning and self-improving from new sessions. ` +
+                            `Existing memories, lessons, and search still work. ` +
+                            `Upgrade for unlimited usage: https://hicortex.gamaze.com/ ` +
+                            `— after purchase, tell me your key and I'll activate it for you.\n`;
+                }
+                return { appendSystemContext: context };
+            }
+            catch {
+                return {};
+            }
+        });
+        // -----------------------------------------------------------------------
+        // Hook: agent_end — distill conversation into memories
+        // -----------------------------------------------------------------------
+        api.on("agent_end", async (event, ctx) => {
+            if (!db || !llm)
+                return;
+            if (!event.success || event.messages.length < 4)
+                return;
+            try {
+                const transcript = (0, distiller_js_1.extractConversationText)(event.messages);
+                if (transcript.length < 200)
+                    return;
+                const date = new Date().toISOString().slice(0, 10);
+                const projectName = ctx.project ?? "unknown";
+                const sourceAgent = `openclaw/${ctx.agentId ?? "unknown"}`;
+                const entries = await (0, distiller_js_1.distillSession)(llm, transcript, projectName, date);
+                if (entries.length === 0)
+                    return;
+                // Check license cap
+                const features = (0, license_js_1.getFeatures)(stateDir);
+                if (features.maxMemories > 0 &&
+                    storage.countMemories(db) >= features.maxMemories) {
+                    console.warn(`[hicortex] Free tier limit reached (${features.maxMemories} memories). ` +
+                        `Search and lessons still work, but new memories won't be saved. ` +
+                        `Upgrade for unlimited usage: https://hicortex.gamaze.com/`);
+                    return;
+                }
+                // Embed and ingest each entry
+                for (const entry of entries) {
+                    try {
+                        const embedding = await (0, embedder_js_1.embed)(entry);
+                        storage.insertMemory(db, entry, embedding, {
+                            sourceAgent,
+                            sourceSession: ctx.sessionKey,
+                            project: projectName,
+                            privacy: "WORK",
+                            memoryType: "episode",
+                        });
+                    }
+                    catch (err) {
+                        const msg = err instanceof Error ? err.message : String(err);
+                        console.error(`[hicortex] Failed to ingest entry: ${msg}`);
+                    }
+                }
+            }
+            catch {
+                // Non-fatal — session capture failing shouldn't break the agent
+            }
+        });
+        // -----------------------------------------------------------------------
+        // Hook: session_end — check if consolidation is overdue
+        // -----------------------------------------------------------------------
+        api.on("session_end", async (event, _ctx) => {
+            if (!db || !llm || event.messageCount < 4)
+                return;
+            // Opportunistic consolidation if no nightly run in 48h
+            try {
+                const { readFileSync: readFs } = await import("node:fs");
+                const { join: joinPath } = await import("node:path");
+                const { homedir: homeDir } = await import("node:os");
+                const lastPath = joinPath(homeDir(), ".claude", "memory", "last-consolidated.txt");
+                const lastTs = readFs(lastPath, "utf-8").trim();
+                const lastDate = new Date(lastTs);
+                const hoursSince = (Date.now() - lastDate.getTime()) / (1000 * 60 * 60);
+                if (hoursSince > 48) {
+                    console.log("[hicortex] Consolidation overdue — triggering now");
+                    (0, consolidate_js_1.runConsolidation)(db, llm, embedder_js_1.embed).catch((err) => {
+                        console.error("[hicortex] Opportunistic consolidation failed:", err);
+                    });
+                }
+            }
+            catch {
+                // No timestamp file — first run, consolidation will happen on schedule
+            }
+        });
+        // -----------------------------------------------------------------------
+        // Tools — registered as factory functions per OC plugin API
+        // -----------------------------------------------------------------------
+        api.registerTool((_ctx) => ({
+            name: "hicortex_search",
+            description: "Search long-term memory using semantic similarity. Returns the most relevant memories from past sessions.",
+            parameters: {
+                type: "object",
+                properties: {
+                    query: { type: "string", description: "Search query text" },
+                    limit: { type: "number", description: "Max results (default 5)" },
+                    project: { type: "string", description: "Filter by project name" },
+                },
+                required: ["query"],
+            },
+            async execute(_callId, args, _ctx) {
+                if (!db)
+                    return { error: "Hicortex not initialized" };
+                try {
+                    const results = await retrieval.retrieve(db, embedder_js_1.embed, args.query, {
+                        limit: args.limit,
+                        project: args.project,
+                    });
+                    return formatToolResults(results);
+                }
+                catch (err) {
+                    return { error: `Search failed: ${err instanceof Error ? err.message : String(err)}` };
+                }
+            },
+        }), { name: "hicortex_search" });
+        api.registerTool((_ctx) => ({
+            name: "hicortex_context",
+            description: "Get recent context memories, optionally filtered by project. Useful to recall what happened recently.",
+            parameters: {
+                type: "object",
+                properties: {
+                    project: { type: "string", description: "Filter by project name" },
+                    limit: { type: "number", description: "Max results (default 10)" },
+                },
+            },
+            execute(_callId, args, _ctx) {
+                if (!db)
+                    return { error: "Hicortex not initialized" };
+                try {
+                    const results = retrieval.searchContext(db, {
+                        project: args?.project,
+                        limit: args?.limit,
+                    });
+                    return formatToolResults(results);
+                }
+                catch (err) {
+                    return { error: `Context search failed: ${err instanceof Error ? err.message : String(err)}` };
+                }
+            },
+        }), { name: "hicortex_context" });
+        api.registerTool((_ctx) => ({
+            name: "hicortex_ingest",
+            description: "Store a new memory in long-term storage. Use for important facts, decisions, or lessons.",
+            parameters: {
+                type: "object",
+                properties: {
+                    content: { type: "string", description: "Memory content to store" },
+                    project: { type: "string", description: "Project this memory belongs to" },
+                    memory_type: {
+                        type: "string",
+                        enum: ["episode", "lesson", "fact", "decision"],
+                        description: "Type of memory (default: episode)",
+                    },
+                },
+                required: ["content"],
+            },
+            async execute(_callId, args, context) {
+                if (!db)
+                    return { error: "Hicortex not initialized" };
+                const features = (0, license_js_1.getFeatures)(stateDir);
+                if (features.maxMemories > 0 && storage.countMemories(db) >= features.maxMemories) {
+                    return {
+                        content: [{
+                                type: "text",
+                                text: `Free tier limit reached (${features.maxMemories} memories). ` +
+                                    `Your existing memories and lessons still work — search and recall are unaffected. ` +
+                                    `New memories won't be saved until you upgrade.\n\n` +
+                                    `Upgrade for unlimited usage: https://hicortex.gamaze.com/`
+                            }],
+                    };
+                }
+                try {
+                    const embedding = await (0, embedder_js_1.embed)(args.content);
+                    const id = storage.insertMemory(db, args.content, embedding, {
+                        sourceAgent: `openclaw/${context?.agentId ?? "manual"}`,
+                        project: args.project,
+                        memoryType: args.memory_type ?? "episode",
+                        privacy: "WORK",
+                    });
+                    return { content: [{ type: "text", text: `Memory stored (id: ${id.slice(0, 8)})` }] };
+                }
+                catch (err) {
+                    return { error: `Ingest failed: ${err instanceof Error ? err.message : String(err)}` };
+                }
+            },
+        }), { name: "hicortex_ingest" });
+        api.registerTool((_ctx) => ({
+            name: "hicortex_lessons",
+            description: "Get actionable lessons learned from past sessions. Auto-generated insights about mistakes to avoid.",
+            parameters: {
+                type: "object",
+                properties: {
+                    days: { type: "number", description: "Look back N days (default 7)" },
+                    project: { type: "string", description: "Filter by project name" },
+                },
+            },
+            execute(_callId, args, _ctx) {
+                if (!db)
+                    return { error: "Hicortex not initialized" };
+                try {
+                    const lessons = storage.getLessons(db, args.days ?? 7, args.project);
+                    if (lessons.length === 0) {
+                        return { content: [{ type: "text", text: "No lessons found for the specified period." }] };
+                    }
+                    const text = lessons.map((l) => `- ${l.content.slice(0, 500)}`).join("\n");
+                    return { content: [{ type: "text", text }] };
+                }
+                catch (err) {
+                    return { error: `Lessons fetch failed: ${err instanceof Error ? err.message : String(err)}` };
+                }
+            },
+        }), { name: "hicortex_lessons" });
+    },
+};
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+// Auto-configure LLM: resolve config → test connection → persist if new
+// ---------------------------------------------------------------------------
+async function autoConfigureLlm(pluginConfig, log) {
+    // Step 1: Resolve LLM config from all sources
+    const llmConfig = (0, llm_js_1.resolveLlmConfig)({
+        llmBaseUrl: pluginConfig.llmBaseUrl,
+        llmApiKey: pluginConfig.llmApiKey,
+        llmModel: pluginConfig.llmModel,
+        reflectModel: pluginConfig.reflectModel,
+    });
+    // Step 2: Test the connection
+    log(`[hicortex] Testing LLM connection: ${llmConfig.provider}/${llmConfig.model} @ ${llmConfig.baseUrl}`);
+    const testClient = new llm_js_1.LlmClient(llmConfig);
+    try {
+        const response = await testClient.completeFast("Respond with just the word OK", 10);
+        if (response && response.length > 0) {
+            log(`[hicortex] LLM connection verified`);
+            // Step 3: Persist to OC config so future startups skip detection
+            persistProviderConfig(llmConfig, log);
+            return llmConfig;
+        }
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        log(`[hicortex] LLM test failed (${llmConfig.baseUrl}): ${msg}`);
+    }
+    // Step 4: If test failed and this is z.ai, try the alternate endpoint
+    if (llmConfig.provider === "zai") {
+        const altUrl = llmConfig.baseUrl.includes("/coding/")
+            ? llmConfig.baseUrl.replace("/coding/", "/")
+            : llmConfig.baseUrl.replace("/api/paas/", "/api/coding/paas/");
+        log(`[hicortex] Trying alternate z.ai endpoint: ${altUrl}`);
+        llmConfig.baseUrl = altUrl;
+        const altClient = new llm_js_1.LlmClient(llmConfig);
+        try {
+            const response = await altClient.completeFast("Respond with just the word OK", 10);
+            if (response && response.length > 0) {
+                log(`[hicortex] LLM connection verified on alternate endpoint`);
+                persistProviderConfig(llmConfig, log);
+                return llmConfig;
+            }
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            log(`[hicortex] Alternate z.ai endpoint also failed: ${msg}`);
+        }
+    }
+    // Step 5: Fall back — return the config anyway, log instructions
+    log(`[hicortex] WARNING: Could not verify LLM connection. ` +
+        `Distillation and consolidation may fail. ` +
+        `To fix: add models.providers.${llmConfig.provider}.baseUrl to ~/.openclaw/openclaw.json ` +
+        `or set llmBaseUrl in the hicortex plugin config.`);
+    return llmConfig;
+}
+/**
+ * Persist verified provider config to openclaw.json so future startups
+ * skip detection and go straight to the verified URL.
+ */
+function persistProviderConfig(llmConfig, log) {
+    try {
+        const configPath = (0, node_path_1.join)((0, node_os_1.homedir)(), ".openclaw", "openclaw.json");
+        const raw = (0, node_fs_2.readFileSync)(configPath, "utf-8");
+        const config = JSON.parse(raw);
+        // Check if baseUrl already stored for this provider
+        const existing = config?.models?.providers?.[llmConfig.provider]?.baseUrl;
+        if (existing === llmConfig.baseUrl)
+            return; // Already persisted
+        // Write the provider config
+        if (!config.models)
+            config.models = {};
+        if (!config.models.providers)
+            config.models.providers = {};
+        if (!config.models.providers[llmConfig.provider]) {
+            config.models.providers[llmConfig.provider] = {};
+        }
+        const prov = config.models.providers[llmConfig.provider];
+        prov.baseUrl = llmConfig.baseUrl;
+        // OC requires a models array — preserve existing or add the active model
+        if (!prov.models || !Array.isArray(prov.models)) {
+            prov.models = [{
+                    id: llmConfig.model,
+                    name: llmConfig.model,
+                    input: ["text"],
+                    contextWindow: 128000,
+                    maxTokens: 8192,
+                }];
+        }
+        (0, node_fs_2.writeFileSync)(configPath, JSON.stringify(config, null, 2));
+        log(`[hicortex] Persisted LLM config: ${llmConfig.provider} → ${llmConfig.baseUrl}`);
+    }
+    catch {
+        // Non-fatal — config works in memory even if we can't persist
+    }
+}
+/**
+ * Track when the memory cap was first hit. Returns days since cap was reached.
+ * Stores timestamp in stateDir/cap-hit.txt on first detection.
+ */
+function getDaysSinceCapHit(dir) {
+    const capFile = (0, node_path_1.join)(dir, "cap-hit.txt");
+    try {
+        const ts = (0, node_fs_2.readFileSync)(capFile, "utf-8").trim();
+        const hitDate = new Date(ts);
+        return Math.floor((Date.now() - hitDate.getTime()) / (1000 * 60 * 60 * 24));
+    }
+    catch {
+        // First time hitting cap — record it
+        try {
+            (0, node_fs_2.writeFileSync)(capFile, new Date().toISOString());
+        }
+        catch { /* non-fatal */ }
+        return 0;
+    }
+}
+const HICORTEX_TOOLS = [
+    "hicortex_search",
+    "hicortex_context",
+    "hicortex_ingest",
+    "hicortex_lessons",
+];
+/**
+ * Ensure hicortex tools are in tools.allow so they're visible to agents
+ * regardless of the tools.profile setting.
+ */
+function ensureToolsAllowed(log) {
+    try {
+        const configPath = (0, node_path_1.join)((0, node_os_1.homedir)(), ".openclaw", "openclaw.json");
+        const raw = (0, node_fs_2.readFileSync)(configPath, "utf-8");
+        const config = JSON.parse(raw);
+        if (!config.tools)
+            config.tools = {};
+        if (!Array.isArray(config.tools.allow))
+            config.tools.allow = [];
+        const missing = HICORTEX_TOOLS.filter((t) => !config.tools.allow.includes(t));
+        if (missing.length === 0)
+            return;
+        config.tools.allow.push(...missing);
+        (0, node_fs_2.writeFileSync)(configPath, JSON.stringify(config, null, 2));
+        log(`[hicortex] Added tools to allow list: ${missing.join(", ")}`);
+    }
+    catch {
+        // Non-fatal
+    }
+}
+// ---------------------------------------------------------------------------
+// Seed lesson — injected on first run, teaches the agent to self-improve
+// ---------------------------------------------------------------------------
+const SEED_LESSON = `## Lesson: 1% Daily Self-Improvement
+
+Self-improvement protocol: Review your sessions daily. Scan for mistakes, gaps, user corrections, and friction. Identify 1-2 issues maximum. Apply one targeted fix to your instruction files (AGENT.md, IDENTITY.md, TOOLS.md, SOUL.md, or CLAUDE.md). Never overcorrect — feedback is guidance, not emergency. One fix per issue. Never rewrite entire systems. Before changing something, ask: is this a real pattern or am I reacting to noise?
+
+The flywheel: Sessions → Hicortex captures → Nightly consolidation → Lessons generated → Lessons injected into your context → You apply one fix → Better sessions tomorrow.
+
+Use hicortex_lessons to check for new insights. If a lesson has high confidence, apply it. If medium, observe for one more day. If nothing needs fixing today, skip — that's fine.
+
+**Severity:** critical
+**Confidence:** high
+**Generated:** seed-lesson`;
+async function injectSeedLesson(database, log) {
+    try {
+        // Check if seed lesson already exists (match on unique content)
+        const existing = storage.getLessons(database, 365);
+        const hasSeed = existing.some((l) => l.content.includes("1% Daily Self-Improvement") ||
+            l.source_agent === "hicortex/seed");
+        if (hasSeed)
+            return;
+        // Embed and store
+        const embedding = await (0, embedder_js_1.embed)(SEED_LESSON);
+        storage.insertMemory(database, SEED_LESSON, embedding, {
+            sourceAgent: "hicortex/seed",
+            project: "global",
+            memoryType: "lesson",
+            baseStrength: 0.95,
+            privacy: "WORK",
+        });
+        log("[hicortex] Seed lesson injected: Daily Self-Improvement Protocol");
+    }
+    catch (err) {
+        // Non-fatal — log but don't crash the plugin
+        const msg = err instanceof Error ? err.message : String(err);
+        log(`[hicortex] Warning: could not inject seed lesson: ${msg}`);
+    }
+}
+function formatToolResults(results) {
+    if (results.length === 0) {
+        return {
+            content: [{ type: "text", text: "No memories found." }],
+        };
+    }
+    const text = results
+        .map((r) => `[${r.memory_type}] (score: ${r.score.toFixed(3)}, strength: ${r.effective_strength.toFixed(3)}) ${r.content.slice(0, 500)}`)
+        .join("\n\n");
+    return { content: [{ type: "text", text }] };
+}

package/dist/license.d.ts

@@ -0,0 +1,5 @@
+import type { LicenseInfo } from "./types.js";
+/** Validate a license key against the Hicortex API */
+export declare function validateLicense(key: string | undefined, stateDir: string): Promise<LicenseInfo>;
+/** Get current features, using cache or free tier defaults */
+export declare function getFeatures(stateDir: string): LicenseInfo["features"];

package/dist/license.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateLicense = validateLicense;
+exports.getFeatures = getFeatures;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const VALIDATE_URL = "https://hicortex.gamaze.com/api/validate";
+const CACHE_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
+const OFFLINE_GRACE_DAYS = 7;
+// In-memory cache
+let cachedLicense = null;
+let cacheTimestamp = 0;
+const FREE_LICENSE = {
+    valid: false,
+    tier: "free",
+    features: {
+        reflection: true,
+        vectorSearch: true,
+        maxMemories: 250,
+        crossAgent: true,
+    },
+};
+/** Validate a license key against the Hicortex API */
+async function validateLicense(key, stateDir) {
+    // No key = free tier
+    if (!key)
+        return FREE_LICENSE;
+    // Check in-memory cache
+    if (cachedLicense && Date.now() - cacheTimestamp < CACHE_TTL_MS) {
+        return cachedLicense;
+    }
+    try {
+        const resp = await fetch(VALIDATE_URL, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ key }),
+            signal: AbortSignal.timeout(10_000),
+        });
+        if (!resp.ok) {
+            throw new Error(`HTTP ${resp.status}`);
+        }
+        const data = (await resp.json());
+        // Cache result
+        cachedLicense = data;
+        cacheTimestamp = Date.now();
+        // Persist last successful validation timestamp for offline grace
+        if (data.valid) {
+            persistValidationTimestamp(stateDir);
+        }
+        return data;
+    }
+    catch {
+        // Network failure — check offline grace period
+        return offlineFallback(key, stateDir);
+    }
+}
+/** Get current features, using cache or free tier defaults */
+function getFeatures(stateDir) {
+    if (cachedLicense)
+        return cachedLicense.features;
+    return FREE_LICENSE.features;
+}
+function persistValidationTimestamp(stateDir) {
+    try {
+        (0, node_fs_1.writeFileSync)((0, node_path_1.join)(stateDir, "license-validated.txt"), new Date().toISOString());
+    }
+    catch {
+        // Non-critical
+    }
+}
+function offlineFallback(key, stateDir) {
+    const tsPath = (0, node_path_1.join)(stateDir, "license-validated.txt");
+    if (!(0, node_fs_1.existsSync)(tsPath))
+        return FREE_LICENSE;
+    try {
+        const lastValidated = new Date((0, node_fs_1.readFileSync)(tsPath, "utf-8").trim());
+        const daysSince = (Date.now() - lastValidated.getTime()) / (1000 * 60 * 60 * 24);
+        if (daysSince <= OFFLINE_GRACE_DAYS) {
+            // Within grace period — assume last known state was valid
+            return cachedLicense ?? {
+                valid: true,
+                tier: "pro",
+                features: {
+                    reflection: true,
+                    vectorSearch: true,
+                    maxMemories: -1,
+                    crossAgent: true,
+                },
+            };
+        }
+    }
+    catch {
+        // Corrupted file
+    }
+    return FREE_LICENSE;
+}