@gamaze/hicortex 0.4.2 → 0.4.4

package/dist/nightly-status.js

@@ -0,0 +1,167 @@
+"use strict";
+/**
+ * Nightly pipeline status — lightweight check without running the pipeline.
+ *
+ * Shows:
+ *   - Last run timestamp + age
+ *   - Timer/schedule status (systemd/launchd)
+ *   - DB memory count
+ *   - Distillation source breakdown
+ *   - Staleness warnings
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.showNightlyStatus = showNightlyStatus;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_os_1 = require("node:os");
+const node_child_process_1 = require("node:child_process");
+const db_js_1 = require("./db.js");
+const HICORTEX_HOME = (0, node_path_1.join)((0, node_os_1.homedir)(), ".hicortex");
+const LAST_RUN_PATH = (0, node_path_1.join)(HICORTEX_HOME, "nightly-last-run.txt");
+const CONFIG_PATH = (0, node_path_1.join)(HICORTEX_HOME, "config.json");
+const STALE_THRESHOLD_HOURS = 30;
+async function showNightlyStatus() {
+    console.log("Hicortex Nightly Pipeline Status");
+    console.log("─".repeat(40));
+    // Last run
+    let lastRun = null;
+    let lastRunStr = "never";
+    try {
+        const ts = (0, node_fs_1.readFileSync)(LAST_RUN_PATH, "utf-8").trim();
+        const d = new Date(ts);
+        if (!isNaN(d.getTime())) {
+            lastRun = d;
+            lastRunStr = ts;
+        }
+        else {
+            lastRunStr = `${ts} (invalid)`;
+        }
+    }
+    catch {
+        // No file
+    }
+    if (lastRun) {
+        const ageMs = Date.now() - lastRun.getTime();
+        const ageHours = Math.round(ageMs / (60 * 60 * 1000));
+        const ageStr = ageHours < 1 ? "just now" :
+            ageHours < 24 ? `${ageHours}h ago` :
+                `${Math.round(ageHours / 24)}d ago`;
+        const isStale = ageHours > STALE_THRESHOLD_HOURS;
+        console.log(`Last run:    ${lastRunStr} (${ageStr})${isStale ? " ⚠ STALE" : ""}`);
+    }
+    else {
+        console.log(`Last run:    ${lastRunStr}`);
+    }
+    // LLM config
+    try {
+        const config = JSON.parse((0, node_fs_1.readFileSync)(CONFIG_PATH, "utf-8"));
+        const backend = config.llmBackend ?? "auto-detect";
+        const model = config.llmModel ?? "default";
+        const mode = config.mode === "client" ? "client → " + (config.serverUrl ?? "?") : "server (local)";
+        console.log(`Mode:        ${mode}`);
+        console.log(`LLM backend: ${backend}${backend !== "auto-detect" ? ` (${model})` : ""}`);
+    }
+    catch {
+        console.log("Config:      not configured (run: hicortex init)");
+    }
+    // Timer/schedule
+    const os = (0, node_os_1.platform)();
+    let timerActive = false;
+    let timerInfo = "not installed";
+    if (os === "darwin") {
+        try {
+            const out = (0, node_child_process_1.execSync)("launchctl list 2>/dev/null | grep hicortex-nightly", {
+                encoding: "utf-8",
+                timeout: 3000,
+            });
+            if (out.trim()) {
+                timerActive = true;
+                timerInfo = "launchd (loaded)";
+            }
+        }
+        catch { /* not installed */ }
+    }
+    else if (os === "linux") {
+        try {
+            const active = (0, node_child_process_1.execSync)("systemctl --user is-active hicortex-nightly.timer 2>/dev/null", {
+                encoding: "utf-8",
+                timeout: 3000,
+            }).trim();
+            if (active === "active" || active === "waiting") {
+                timerActive = true;
+                try {
+                    const next = (0, node_child_process_1.execSync)("systemctl --user show hicortex-nightly.timer --property=NextElapseUSecRealtime 2>/dev/null", {
+                        encoding: "utf-8",
+                        timeout: 3000,
+                    }).trim();
+                    const match = next.match(/=(\d+)/);
+                    if (match) {
+                        const nextDate = new Date(Number(match[1]) / 1000);
+                        timerInfo = `systemd (active, next: ${nextDate.toISOString()})`;
+                    }
+                    else {
+                        timerInfo = `systemd (${active})`;
+                    }
+                }
+                catch {
+                    timerInfo = `systemd (${active})`;
+                }
+            }
+        }
+        catch { /* not installed */ }
+    }
+    console.log(`Timer:       ${timerInfo}${!timerActive ? " ⚠ Pipeline will NOT run automatically" : ""}`);
+    // DB stats
+    const dbPath = (0, db_js_1.resolveDbPath)();
+    if ((0, node_fs_1.existsSync)(dbPath)) {
+        try {
+            const { initDb } = await import("./db.js");
+            const db = initDb(dbPath);
+            const count = db.prepare("SELECT COUNT(*) as c FROM memories").get().c;
+            let linkCount = 0;
+            try {
+                linkCount = db.prepare("SELECT COUNT(*) as c FROM memory_links").get().c;
+            }
+            catch {
+                // memory_links table may not exist in older DBs
+            }
+            // Source breakdown (top 5)
+            const sources = db.prepare("SELECT source_agent, COUNT(*) as cnt FROM memories GROUP BY source_agent ORDER BY cnt DESC LIMIT 5").all();
+            console.log(`\nMemories:    ${count} (${linkCount} links)`);
+            if (sources.length > 0) {
+                console.log("Sources:");
+                for (const s of sources) {
+                    console.log(`  ${s.source_agent || "unknown"}: ${s.cnt}`);
+                }
+            }
+            db.close();
+        }
+        catch (err) {
+            console.log(`\nDB:          error (${err instanceof Error ? err.message : String(err)})`);
+        }
+    }
+    else {
+        console.log(`\nDB:          not found (run: hicortex init)`);
+    }
+    // Health assessment
+    console.log("\n" + "─".repeat(40));
+    const issues = [];
+    if (!lastRun)
+        issues.push("Pipeline has never run. Run: hicortex nightly");
+    else if (lastRun && (Date.now() - lastRun.getTime()) > STALE_THRESHOLD_HOURS * 60 * 60 * 1000) {
+        issues.push(`Pipeline hasn't run in ${STALE_THRESHOLD_HOURS}+ hours. Check timer.`);
+    }
+    if (!timerActive)
+        issues.push("No timer installed. Nightly pipeline won't run automatically.");
+    if (!(0, node_fs_1.existsSync)(dbPath))
+        issues.push("No database found. Run: hicortex init");
+    if (issues.length === 0) {
+        console.log("✓ Nightly pipeline healthy");
+    }
+    else {
+        console.log("Issues:");
+        for (const issue of issues) {
+            console.log(`  ⚠ ${issue}`);
+        }
+    }
+}

package/dist/nightly.js

@@ -55,9 +55,10 @@ const distiller_js_1 = require("./distiller.js");
 const consolidate_js_1 = require("./consolidate.js");
 const transcript_reader_js_1 = require("./transcript-reader.js");
 const claude_md_js_1 = require("./claude-md.js");
-const license_js_1 = require("./license.js");
+const features_js_1 = require("./features.js");
+const extensions_js_1 = require("./extensions.js");
+const state_js_1 = require("./state.js");
 const HICORTEX_HOME = (0, node_path_1.join)((0, node_os_1.homedir)(), ".hicortex");
-const LAST_RUN_PATH = (0, node_path_1.join)(HICORTEX_HOME, "nightly-last-run.txt");
 function readNightlyConfig(stateDir) {
     try {
         const configPath = (0, node_path_1.join)(stateDir, "config.json");
@@ -78,25 +79,24 @@ function readConfigLicenseKey(stateDir) {
         return undefined;
     }
 }
-function readLastRun() {
-    try {
-        const ts = (0, node_fs_1.readFileSync)(LAST_RUN_PATH, "utf-8").trim();
-        const d = new Date(ts);
-        if (!isNaN(d.getTime()))
-            return d;
-    }
-    catch {
-        // No file — first run
-    }
-    return new Date(0); // Process everything
+function readLastRun(stateDir = HICORTEX_HOME) {
+    const ts = (0, state_js_1.loadState)(stateDir).lastNightly;
+    if (!ts)
+        return new Date(0); // First run — process everything
+    const d = new Date(ts);
+    return isNaN(d.getTime()) ? new Date(0) : d;
 }
-function writeLastRun() {
-    (0, node_fs_1.mkdirSync)(HICORTEX_HOME, { recursive: true });
-    (0, node_fs_1.writeFileSync)(LAST_RUN_PATH, new Date().toISOString());
+function writeLastRun(stateDir = HICORTEX_HOME) {
+    (0, state_js_1.updateState)((s) => {
+        s.lastNightly = new Date().toISOString();
+        return s;
+    }, stateDir);
 }
 async function runNightly(options = {}) {
     const dryRun = options.dryRun ?? false;
     const stateDir = options.stateDir ?? HICORTEX_HOME;
+    // One-time migration of legacy state files (no-op if state.json exists)
+    (0, state_js_1.migrateLegacyState)(stateDir);
     // Check mode: client or server
     const savedConfig = readNightlyConfig(stateDir);
     if (savedConfig?.mode === "client") {
@@ -109,9 +109,9 @@ async function runNightly(options = {}) {
     // Init DB
     const db = (0, db_js_1.initDb)(dbPath);
     try {
-        // License: read from config file or env var
+        // License: read from config file or env var, init feature cache
         const licenseKey = readConfigLicenseKey(stateDir) ?? process.env.HICORTEX_LICENSE_KEY;
-        await (0, license_js_1.validateLicense)(licenseKey, stateDir);
+        await (0, features_js_1.initFeatures)(licenseKey, stateDir);
         // Init LLM: check config.json first, then auto-detect
         let llmConfig;
         const savedConfig = readNightlyConfig(stateDir);
@@ -182,7 +182,6 @@ async function runNightly(options = {}) {
         }
         // Step 2: Distill each session
         let memoriesIngested = 0;
-        const features = (0, license_js_1.getFeatures)(stateDir);
         // Detect safe chunk size based on model context window
         const chunkSize = await (0, distiller_js_1.detectChunkSize)(llmConfig.provider, llmConfig.distillModel ?? llmConfig.model, llmConfig.baseUrl);
         for (const batch of batches) {
@@ -197,8 +196,8 @@ async function runNightly(options = {}) {
                 continue;
             }
             // Check cap before distilling
-            if (features.maxMemories > 0 && storage.countMemories(db) >= features.maxMemories) {
-                console.log(`[hicortex]   Free tier limit (${features.maxMemories} memories). Skipping new ingestion. ` +
+            if ((0, features_js_1.memoryCapReached)(storage.countMemories(db))) {
+                console.log(`[hicortex]   Free tier limit (${(0, features_js_1.maxMemoriesAllowed)()} memories). Skipping new ingestion. ` +
                     `Upgrade: https://hicortex.gamaze.com/`);
                 break;
             }
@@ -238,7 +237,7 @@ async function runNightly(options = {}) {
         }
         // Step 4: Inject lessons into CLAUDE.md
         if (!dryRun) {
-            const injection = (0, claude_md_js_1.injectLessons)(db, { stateDir });
+            const injection = await (0, claude_md_js_1.injectLessons)(db, { stateDir });
             console.log(`[hicortex] CLAUDE.md updated: ${injection.lessonsCount} lessons at ${injection.path}`);
         }
         // Step 5: Update last-run timestamp
@@ -400,7 +399,88 @@ async function runClientNightly(config, dryRun) {
             console.error(`[hicortex]     Failed: ${err instanceof Error ? err.message : String(err)}`);
         }
     }
+    // Inject lessons from server into CLAUDE.md
+    if (!dryRun) {
+        try {
+            await injectLessonsFromServer(serverUrl, authToken);
+        }
+        catch (err) {
+            console.error(`[hicortex] CLAUDE.md injection failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
     if (!dryRun)
         writeLastRun();
     console.log(`[hicortex] Client nightly complete: ${memoriesIngested} memories from ${sessionsSent} sessions → ${serverUrl}`);
 }
+/**
+ * Fetch lessons + memory index from server and inject into CLAUDE.md.
+ * Client mode equivalent of the server's injectLessons(db, ...).
+ */
+async function injectLessonsFromServer(serverUrl, authToken) {
+    const resp = await fetch(`${serverUrl}/lessons`, {
+        headers: authToken ? { "Authorization": `Bearer ${authToken}` } : {},
+        signal: AbortSignal.timeout(10_000),
+    });
+    if (!resp.ok) {
+        console.log(`[hicortex] Could not fetch lessons from server (${resp.status})`);
+        return;
+    }
+    const data = await resp.json();
+    const maxLessons = (0, features_js_1.lessonsLimit)();
+    const selected = await (0, extensions_js_1.getLessonSelector)().select(data.lessons, { maxLessons });
+    // Format lessons
+    const lessonLines = selected.map((l) => {
+        const titleMatch = l.content.match(/## Lesson: (.+)/);
+        const typeMatch = l.content.match(/\*\*Type:\*\* (\w+)/);
+        const severityMatch = l.content.match(/\*\*Severity:\*\* (\w+)/);
+        const title = titleMatch ? titleMatch[1] : l.content.slice(0, 150);
+        const meta = [severityMatch?.[1], typeMatch?.[1]].filter(Boolean).join(", ");
+        return `- ${title}${meta ? ` (${meta})` : ""}`;
+    });
+    // Format project index
+    const projectIndex = data.index.projects.map(p => `${p.name}: ${p.count}`);
+    // Build block
+    const START_MARKER = "<!-- HICORTEX-LEARNINGS:START -->";
+    const END_MARKER = "<!-- HICORTEX-LEARNINGS:END -->";
+    const blockParts = [START_MARKER, "## Hicortex Memory"];
+    blockParts.push("", "You have access to shared long-term memory across all agents and sessions.", "BEFORE making decisions, search memory: `hicortex_search` for prior decisions on the same topic.", "Use `hicortex_context` at session start for recent project state.");
+    if (lessonLines.length > 0) {
+        blockParts.push("", "### Lessons (updated nightly)");
+        blockParts.push(...lessonLines);
+    }
+    else {
+        blockParts.push("", "### Getting Started");
+        blockParts.push("- Search past decisions with `hicortex_search` before starting work");
+        blockParts.push("- Save important decisions with `hicortex_ingest`");
+        blockParts.push("- Lessons will appear here after the first nightly run");
+    }
+    if (projectIndex.length > 0) {
+        blockParts.push("", "### Memory Index");
+        blockParts.push(projectIndex.join(" | "));
+        blockParts.push(`${data.index.total} memories, ${data.index.lessonCount} lessons, ${data.index.sourceCount} agents. Search with \`hicortex_search\`.`);
+    }
+    blockParts.push(END_MARKER);
+    const block = blockParts.join("\n");
+    // Write to CLAUDE.md (uses fs/path/os already imported at top of file)
+    const claudeMdPath = (0, node_path_1.join)((0, node_os_1.homedir)(), ".claude", "CLAUDE.md");
+    let content = "";
+    try {
+        content = (0, node_fs_1.readFileSync)(claudeMdPath, "utf-8");
+    }
+    catch { }
+    const startIdx = content.indexOf(START_MARKER);
+    const endIdx = content.indexOf(END_MARKER);
+    if (startIdx !== -1 && endIdx !== -1) {
+        content = content.slice(0, startIdx) + block + content.slice(endIdx + END_MARKER.length);
+    }
+    else {
+        if (content.length > 0 && !content.endsWith("\n"))
+            content += "\n";
+        if (content.length > 0)
+            content += "\n";
+        content += block + "\n";
+    }
+    (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(claudeMdPath), { recursive: true });
+    (0, node_fs_1.writeFileSync)(claudeMdPath, content);
+    console.log(`[hicortex] CLAUDE.md updated: ${lessonLines.length} lessons, ${data.index.total} memories indexed`);
+}

package/dist/state.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Centralized state management — single ~/.hicortex/state.json file.
+ *
+ * Replaces 4 separate state files used by previous versions:
+ *   - nightly-last-run.txt   → state.lastNightly
+ *   - last-consolidated.txt  → state.lastConsolidated
+ *   - tier.json              → state.tier
+ *   - license-validated.txt  → state.tier.validatedAt (subsumed)
+ *
+ * Why one file:
+ *   - Atomic writes (write to temp + rename)
+ *   - Easier debugging (one file to inspect)
+ *   - No filesystem chatter from multiple separate writes
+ *   - Single migration path going forward
+ *
+ * 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";
+/** Persisted tier information — reflects the last successful validation. */
+export interface PersistedTier {
+    /** Tier name from the validation API response. */
+    tier: LicenseInfo["tier"];
+    /** ISO timestamp of when this tier was validated against the API. */
+    validatedAt: string;
+    /** Cached features object — used by features.ts and offline fallback. */
+    features: LicenseInfo["features"];
+}
+export interface HicortexState {
+    /** ISO timestamp of the last nightly transcript scan watermark. */
+    lastNightly?: string;
+    /** ISO timestamp of the last consolidation pipeline run. */
+    lastConsolidated?: string;
+    /** Last-known license tier (replaces tier.json + license-validated.txt). */
+    tier?: PersistedTier;
+}
+/**
+ * Load the state file. Returns an empty state if the file is missing
+ * or corrupted (callers should handle missing fields with defaults).
+ */
+export declare function loadState(stateDir?: string): HicortexState;
+/**
+ * Atomically write the state file. Uses write-to-temp + rename so a crash
+ * during write cannot leave a half-written state.json on disk.
+ */
+export declare function saveState(state: HicortexState, stateDir?: string): void;
+/**
+ * Read-modify-write helper. The updater receives the current state and
+ * returns the next state (or void if it mutates in place).
+ */
+export declare function updateState(updater: (state: HicortexState) => HicortexState | void, stateDir?: string): HicortexState;
+/**
+ * One-time migration from the 4 legacy state files to state.json.
+ *
+ * Behaviour:
+ *   1. If state.json already exists, do nothing (and clean up any leftover
+ *      legacy files from a previously interrupted migration).
+ *   2. Otherwise, read whichever legacy files exist, build a HicortexState,
+ *      write state.json, and delete the legacy files.
+ *
+ * Idempotent: safe to call on every boot.
+ * Returns true if migration ran, false if state.json already existed.
+ */
+export declare function migrateLegacyState(stateDir?: string): boolean;

package/dist/state.js

@@ -0,0 +1,162 @@
+"use strict";
+/**
+ * Centralized state management — single ~/.hicortex/state.json file.
+ *
+ * Replaces 4 separate state files used by previous versions:
+ *   - nightly-last-run.txt   → state.lastNightly
+ *   - last-consolidated.txt  → state.lastConsolidated
+ *   - tier.json              → state.tier
+ *   - license-validated.txt  → state.tier.validatedAt (subsumed)
+ *
+ * Why one file:
+ *   - Atomic writes (write to temp + rename)
+ *   - Easier debugging (one file to inspect)
+ *   - No filesystem chatter from multiple separate writes
+ *   - Single migration path going forward
+ *
+ * Note: ~/.hicortex/config.json is intentionally NOT merged here. Config is
+ * user-edited and tracked separately from machine state.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadState = loadState;
+exports.saveState = saveState;
+exports.updateState = updateState;
+exports.migrateLegacyState = migrateLegacyState;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_os_1 = require("node:os");
+const HICORTEX_HOME = (0, node_path_1.join)((0, node_os_1.homedir)(), ".hicortex");
+const STATE_FILE = "state.json";
+/**
+ * Load the state file. Returns an empty state if the file is missing
+ * or corrupted (callers should handle missing fields with defaults).
+ */
+function loadState(stateDir = HICORTEX_HOME) {
+    const path = (0, node_path_1.join)(stateDir, STATE_FILE);
+    try {
+        const raw = (0, node_fs_1.readFileSync)(path, "utf-8");
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === "object" ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * Atomically write the state file. Uses write-to-temp + rename so a crash
+ * during write cannot leave a half-written state.json on disk.
+ */
+function saveState(state, stateDir = HICORTEX_HOME) {
+    try {
+        (0, node_fs_1.mkdirSync)(stateDir, { recursive: true });
+        const path = (0, node_path_1.join)(stateDir, STATE_FILE);
+        const tmp = `${path}.tmp`;
+        (0, node_fs_1.writeFileSync)(tmp, JSON.stringify(state, null, 2));
+        (0, node_fs_1.renameSync)(tmp, path);
+    }
+    catch (err) {
+        console.warn(`[hicortex] Failed to save state: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+/**
+ * Read-modify-write helper. The updater receives the current state and
+ * returns the next state (or void if it mutates in place).
+ */
+function updateState(updater, stateDir = HICORTEX_HOME) {
+    const current = loadState(stateDir);
+    const result = updater(current);
+    const next = result ?? current;
+    saveState(next, stateDir);
+    return next;
+}
+// ---------------------------------------------------------------------------
+// One-time legacy migration
+// ---------------------------------------------------------------------------
+const LEGACY_FILES = [
+    "nightly-last-run.txt",
+    "last-consolidated.txt",
+    "license-validated.txt",
+    "tier.json",
+];
+/**
+ * One-time migration from the 4 legacy state files to state.json.
+ *
+ * Behaviour:
+ *   1. If state.json already exists, do nothing (and clean up any leftover
+ *      legacy files from a previously interrupted migration).
+ *   2. Otherwise, read whichever legacy files exist, build a HicortexState,
+ *      write state.json, and delete the legacy files.
+ *
+ * Idempotent: safe to call on every boot.
+ * Returns true if migration ran, false if state.json already existed.
+ */
+function migrateLegacyState(stateDir = HICORTEX_HOME) {
+    const statePath = (0, node_path_1.join)(stateDir, STATE_FILE);
+    if ((0, node_fs_1.existsSync)(statePath)) {
+        cleanupLegacyFiles(stateDir);
+        return false;
+    }
+    const state = {};
+    let foundAny = false;
+    // 1. nightly-last-run.txt → state.lastNightly
+    const ln = readLegacyText(stateDir, "nightly-last-run.txt");
+    if (ln) {
+        state.lastNightly = ln;
+        foundAny = true;
+    }
+    // 2. last-consolidated.txt → state.lastConsolidated
+    const lc = readLegacyText(stateDir, "last-consolidated.txt");
+    if (lc) {
+        state.lastConsolidated = lc;
+        foundAny = true;
+    }
+    // 3. tier.json → state.tier (full object)
+    const tierRaw = readLegacyText(stateDir, "tier.json");
+    if (tierRaw) {
+        try {
+            state.tier = JSON.parse(tierRaw);
+            foundAny = true;
+        }
+        catch {
+            // Corrupted tier.json — ignore
+        }
+    }
+    // 4. license-validated.txt → state.tier.validatedAt (only if no tier yet)
+    //    (subsumed by tier.json when it exists)
+    if (!state.tier) {
+        const lv = readLegacyText(stateDir, "license-validated.txt");
+        if (lv) {
+            // We have a validation timestamp but no tier object — preserve as
+            // a placeholder so offline grace can still work. The features module
+            // will re-validate on next boot to get the full features back.
+            // We deliberately don't fabricate features here.
+            foundAny = true;
+        }
+    }
+    if (foundAny) {
+        saveState(state, stateDir);
+        cleanupLegacyFiles(stateDir);
+        console.log("[hicortex] Migrated legacy state files to ~/.hicortex/state.json");
+        return true;
+    }
+    return false;
+}
+function readLegacyText(stateDir, name) {
+    try {
+        const raw = (0, node_fs_1.readFileSync)((0, node_path_1.join)(stateDir, name), "utf-8").trim();
+        return raw || null;
+    }
+    catch {
+        return null;
+    }
+}
+function cleanupLegacyFiles(stateDir) {
+    for (const name of LEGACY_FILES) {
+        try {
+            (0, node_fs_1.unlinkSync)((0, node_path_1.join)(stateDir, name));
+        }
+        catch {
+            // File didn't exist — fine
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gamaze/hicortex",
-  "version": "0.4.2",
+  "version": "0.4.4",
   "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": {
@@ -45,13 +45,17 @@
   "engines": {
     "node": ">=18"
   },
-  "license": "UNLICENSED",
+  "license": "MIT",
   "homepage": "https://hicortex.gamaze.com",
   "repository": {
     "type": "git",
-    "url": "https://github.com/mha33/hicortex.git",
+    "url": "https://github.com/gamaze-labs/hicortex.git",
     "directory": "packages/openclaw-plugin"
   },
+  "bugs": {
+    "url": "https://github.com/gamaze-labs/hicortex/issues"
+  },
+  "author": "Mattias Hansson",
   "dependencies": {
     "@huggingface/transformers": "^3.0.0",
     "@modelcontextprotocol/sdk": "^1.28.0",