@gamaze/hicortex 0.2.1 → 0.3.0

package/README.md

@@ -2,51 +2,68 @@
 
 Upgrade your agents with Hicortex for automatic capturing of experiences, feedback, and decisions across all your connected agents. They start learning from every session, self-reflect, avoid past mistakes, and improve on their own — overnight, automatically. No configuration needed.
 
+Works with **OpenClaw** (in-process plugin) and **Claude Code** (HTTP/SSE MCP server).
+
 ## Requirements
 
-- OpenClaw gateway (Node.js 18+)
-- LLM provider configured in OpenClaw (auto-detected, 20+ providers supported)
+- Node.js 18+
+- LLM provider (auto-detected from OC config or `ANTHROPIC_API_KEY` for CC)
 - ~500MB disk for database + embedding model
 
-## Install
+## Install — OpenClaw
 
 ```bash
 openclaw plugins install @gamaze/hicortex
+openclaw gateway restart
 ```
 
-## Configure
+No configuration needed. The plugin auto-detects your LLM provider from OpenClaw settings on first startup.
+
+## Install — Claude Code
 
-No configuration needed for most users. The plugin auto-detects your LLM provider from OpenClaw settings on first startup.
+```bash
+npx @gamaze/hicortex init
+```
 
-Optional config (add to plugin entry in `~/.openclaw/openclaw.json`):
+This detects your environment, installs a persistent MCP server daemon, registers it with Claude Code, and adds `/learn` and `/hicortex-activate` commands. Restart CC after setup.
+
+Or manually:
+
+```bash
+# Start server
+npx @gamaze/hicortex server
+
+# Register with CC
+claude mcp add hicortex --transport http http://localhost:8787/sse
+```
+
+## Configure
+
+Optional config for OC (add to plugin entry in `~/.openclaw/openclaw.json`):
 
 | Field | Default | Description |
 |-------|---------|-------------|
 | `licenseKey` | _(none)_ | License key. Free tier (250 memories) without key. |
-| `llmBaseUrl` | _(auto)_ | Override LLM base URL (auto-detected from OC config) |
-| `llmApiKey` | _(auto)_ | Override LLM API key (auto-detected from OC auth) |
+| `llmBaseUrl` | _(auto)_ | Override LLM base URL |
+| `llmApiKey` | _(auto)_ | Override LLM API key |
 | `llmModel` | _(auto)_ | Override model for scoring and distillation |
 | `reflectModel` | _(auto)_ | Override model for nightly reflection |
 | `consolidateHour` | `2` | Hour (0-23, local time) for nightly consolidation |
 | `dbPath` | _(auto)_ | Custom database path |
 
-Restart the gateway after config changes:
-
-```bash
-openclaw gateway restart
-```
+For CC, set environment variables: `ANTHROPIC_API_KEY` (auto-detected), or `HICORTEX_LLM_BASE_URL` + `HICORTEX_LLM_API_KEY` + `HICORTEX_LLM_MODEL` for custom providers.
 
 ## What Happens Automatically
 
 | When | What | How |
 |------|------|-----|
-| Agent start | Recent lessons injected into context | `before_agent_start` hook |
-| Agent end | Conversation captured and distilled | `agent_end` hook + LLM |
+| Agent start | Recent lessons injected into context | OC: `before_agent_start` hook / CC: CLAUDE.md block |
+| Agent end | Conversation captured and distilled | OC: `agent_end` hook / CC: nightly transcript scan |
 | Nightly | Score importance, reflect, link, decay | In-process consolidation pipeline |
 
 ## Agent Tools
 
-The plugin registers these tools for agents to use:
+Available via MCP (both OC and CC):
 
 - **hicortex_search** — Semantic search across all stored knowledge
 - **hicortex_context** — Get recent decisions and project state
@@ -55,22 +72,41 @@ The plugin registers these tools for agents to use:
 
 Skills: `/learn` to save explicit learnings.
 
+## CLI Commands
+
+```bash
+npx @gamaze/hicortex server      # Start MCP HTTP/SSE server (port 8787)
+npx @gamaze/hicortex init        # Set up for Claude Code
+npx @gamaze/hicortex nightly     # Run distill + consolidate + inject
+npx @gamaze/hicortex status      # Show config, DB stats, adapters
+npx @gamaze/hicortex uninstall   # Remove CC integration (keeps DB)
+```
+
 ## Architecture
 
 ```
-OpenClaw Gateway (Node.js)
-  └── @gamaze/hicortex plugin (TypeScript, in-process)
-      ├── before_agent_start → inject lessons into agent context
-      ├── agent_end → capture conversation, distill via LLM
-      ├── session_end → check if consolidation overdue
-      ├── registerTool → hicortex_search, hicortex_context, hicortex_ingest, hicortex_lessons
-      └── registerService → DB init, LLM auto-config, nightly consolidation
-          ├── SQLite + sqlite-vec + FTS5 (single file, in-process)
-          ├── bge-small-en-v1.5 embeddings (ONNX, local CPU)
-          └── BM25 + vector search with RRF fusion
+@gamaze/hicortex (single npm package, dual mode)
+├── OpenClaw mode (in-process plugin)
+│   ├── before_agent_start → inject lessons
+│   ├── agent_end → capture + distill
+│   └── registerService → DB, LLM, consolidation timer
+│
+└── Claude Code mode (persistent HTTP/SSE server)
+    ├── MCP tools → hicortex_search, hicortex_context, hicortex_ingest, hicortex_lessons
+    ├── /health endpoint → monitoring
+    ├── Nightly → scan CC transcripts, distill, consolidate, inject CLAUDE.md
+    └── Shared DB at ~/.hicortex/hicortex.db
+
+Shared core:
+  ├── SQLite + sqlite-vec + FTS5 (single file)
+  ├── bge-small-en-v1.5 embeddings (ONNX, local CPU)
+  ├── BM25 + vector search with RRF fusion
+  └── Multi-provider LLM (20+ providers)
 ```
 
-No sidecar, no HTTP server, no separate process. Everything runs inside the gateway.
+## Database
+
+Canonical location: `~/.hicortex/hicortex.db`. Existing OC installations at `~/.openclaw/data/hicortex.db` are automatically migrated on upgrade.
 
 ## Pricing
 
@@ -85,33 +121,37 @@ Get a license key at [hicortex.gamaze.com](https://hicortex.gamaze.com).
 
 ## Uninstall
 
+**OpenClaw:**
 ```bash
 openclaw plugins uninstall hicortex
 ```
 
-Your memory database is preserved by default. To remove it: delete `~/.openclaw/data/hicortex.db`.
+**Claude Code:**
+```bash
+npx @gamaze/hicortex uninstall
+```
+
+Your memory database is preserved by default. To remove all data: `rm -rf ~/.hicortex`
 
 ## Development
 
 ```bash
-# Local dev install
-openclaw plugins install -l ./packages/openclaw-plugin
-
-# Build
 cd packages/openclaw-plugin
 npm install
 npm run build
-
-# Test
 npm test
 ```
 
 ## Troubleshooting
 
-**Tools not visible to agent:** The plugin auto-adds tools to `tools.allow` on startup. If tools still don't appear, check that the gateway was restarted after install.
+**Tools not visible to agent (OC):** The plugin auto-adds tools to `tools.allow` on startup. Restart the gateway after install.
 
-**LLM auto-config failed:** Check the gateway log for `[hicortex] WARNING`. You may need to add `llmBaseUrl` to the plugin config manually for non-standard providers.
+**LLM auto-config failed:** Check logs for `[hicortex] WARNING`. Add `llmBaseUrl` to plugin config or set `HICORTEX_LLM_BASE_URL` env var.
 
-**No lessons generated:** Reflection requires an LLM. Check that your LLM provider is accessible and has sufficient quota.
+**No lessons generated:** Reflection requires an LLM. Check that your provider is accessible and has sufficient quota.
 
 **First startup slow:** The embedding model (~130MB) downloads on first run. Allow up to 2 minutes.
+
+**Server won't start (CC):** Check `~/.hicortex/server.log` for errors. Verify port 8787 is free: `lsof -i :8787`.
+
+**Multiple CC sessions:** The HTTP server handles multiple concurrent sessions. Do not use stdio transport — it spawns separate processes per session.

package/dist/claude-md.d.ts

@@ -0,0 +1,28 @@
+/**
+ * CLAUDE.md lesson injection — manages the Hicortex Learnings block.
+ *
+ * Writes a delimited block into ~/.claude/CLAUDE.md containing:
+ * - Agent guidance for proactive tool use
+ * - Active lessons from the DB
+ *
+ * Idempotent: calling twice with the same lessons produces the same file.
+ */
+import type Database from "better-sqlite3";
+/**
+ * Inject lessons from the DB into CLAUDE.md.
+ * Creates the file if it doesn't exist.
+ * Replaces existing block if present, appends if not.
+ */
+export declare function injectLessons(db: Database.Database, options?: {
+    claudeMdPath?: string;
+    stateDir?: string;
+    project?: string;
+}): {
+    lessonsCount: number;
+    path: string;
+};
+/**
+ * Remove the Hicortex Learnings block from CLAUDE.md.
+ * Used by the uninstall command.
+ */
+export declare function removeLessonsBlock(claudeMdPath?: string): boolean;

package/dist/claude-md.js

@@ -0,0 +1,142 @@
+"use strict";
+/**
+ * CLAUDE.md lesson injection — manages the Hicortex Learnings block.
+ *
+ * Writes a delimited block into ~/.claude/CLAUDE.md containing:
+ * - Agent guidance for proactive tool use
+ * - Active lessons from the DB
+ *
+ * Idempotent: calling twice with the same lessons produces the same file.
+ */
+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 });
+exports.injectLessons = injectLessons;
+exports.removeLessonsBlock = removeLessonsBlock;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_path_2 = require("node:path");
+const node_os_1 = require("node:os");
+const storage = __importStar(require("./storage.js"));
+const license_js_1 = require("./license.js");
+const START_MARKER = "<!-- HICORTEX-LEARNINGS:START -->";
+const END_MARKER = "<!-- HICORTEX-LEARNINGS:END -->";
+const DEFAULT_CLAUDE_MD = (0, node_path_2.join)((0, node_os_1.homedir)(), ".claude", "CLAUDE.md");
+const AGENT_GUIDANCE = `You have access to long-term memory via Hicortex MCP tools. Use \`hicortex_search\` when you need context from past sessions, decisions, or prior work. Use \`hicortex_context\` at session start to recall recent project state. Use \`hicortex_ingest\` to save important decisions or learnings. Sessions are auto-captured nightly.`;
+/**
+ * Inject lessons from the DB into CLAUDE.md.
+ * Creates the file if it doesn't exist.
+ * Replaces existing block if present, appends if not.
+ */
+function injectLessons(db, options = {}) {
+    const claudeMdPath = options.claudeMdPath ?? DEFAULT_CLAUDE_MD;
+    const stateDir = options.stateDir ?? (0, node_path_2.join)((0, node_os_1.homedir)(), ".hicortex");
+    // Determine lesson limit based on license
+    const features = (0, license_js_1.getFeatures)(stateDir);
+    const maxLessons = features.maxMemories === -1 ? 15 : 7;
+    // Load lessons
+    const lessons = storage.getLessons(db, 30, options.project);
+    const selected = lessons.slice(0, maxLessons);
+    // Format lesson lines
+    const lessonLines = selected.map((l) => {
+        const match = l.content.match(/## Lesson: (.+)/);
+        return match ? `- ${match[1]}` : `- ${l.content.slice(0, 200)}`;
+    });
+    // Build the block
+    const blockParts = [START_MARKER, "## Hicortex Learnings", "", AGENT_GUIDANCE];
+    if (lessonLines.length > 0) {
+        blockParts.push("", "### Active Lessons");
+        blockParts.push(...lessonLines);
+    }
+    blockParts.push(END_MARKER);
+    const block = blockParts.join("\n");
+    // Read existing file or start empty
+    let content = "";
+    try {
+        content = (0, node_fs_1.readFileSync)(claudeMdPath, "utf-8");
+    }
+    catch {
+        // File doesn't exist — will create it
+    }
+    // Replace or append
+    const startIdx = content.indexOf(START_MARKER);
+    const endIdx = content.indexOf(END_MARKER);
+    if (startIdx !== -1 && endIdx !== -1) {
+        // Replace existing block
+        content =
+            content.slice(0, startIdx) +
+                block +
+                content.slice(endIdx + END_MARKER.length);
+    }
+    else {
+        // Append with blank line separator
+        if (content.length > 0 && !content.endsWith("\n")) {
+            content += "\n";
+        }
+        if (content.length > 0) {
+            content += "\n";
+        }
+        content += block + "\n";
+    }
+    // Write
+    (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(claudeMdPath), { recursive: true });
+    (0, node_fs_1.writeFileSync)(claudeMdPath, content);
+    return { lessonsCount: selected.length, path: claudeMdPath };
+}
+/**
+ * Remove the Hicortex Learnings block from CLAUDE.md.
+ * Used by the uninstall command.
+ */
+function removeLessonsBlock(claudeMdPath = DEFAULT_CLAUDE_MD) {
+    let content;
+    try {
+        content = (0, node_fs_1.readFileSync)(claudeMdPath, "utf-8");
+    }
+    catch {
+        return false; // File doesn't exist
+    }
+    const startIdx = content.indexOf(START_MARKER);
+    const endIdx = content.indexOf(END_MARKER);
+    if (startIdx === -1 || endIdx === -1)
+        return false;
+    // Remove block and any trailing blank line
+    let newContent = content.slice(0, startIdx) +
+        content.slice(endIdx + END_MARKER.length);
+    // Clean up double blank lines left by removal
+    newContent = newContent.replace(/\n{3,}/g, "\n\n").trim();
+    if (newContent.length > 0)
+        newContent += "\n";
+    (0, node_fs_1.writeFileSync)(claudeMdPath, newContent);
+    return true;
+}

package/dist/cli.d.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+/**
+ * Hicortex CLI — entry point for `npx @gamaze/hicortex <command>`.
+ *
+ * Commands:
+ *   server     Start the MCP HTTP/SSE server (persistent daemon)
+ *   init       Detect existing setup and configure for CC/OC
+ *   nightly    Run distill + consolidate + inject lessons (manual trigger)
+ *   status     Show config, DB stats, adapter status
+ *   uninstall  Clean removal of CC integration
+ */
+export {};

package/dist/cli.js

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * Hicortex CLI — entry point for `npx @gamaze/hicortex <command>`.
+ *
+ * Commands:
+ *   server     Start the MCP HTTP/SSE server (persistent daemon)
+ *   init       Detect existing setup and configure for CC/OC
+ *   nightly    Run distill + consolidate + inject lessons (manual trigger)
+ *   status     Show config, DB stats, adapter status
+ *   uninstall  Clean removal of CC integration
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const command = process.argv[2];
+switch (command) {
+    case "server": {
+        const portArg = process.argv.indexOf("--port");
+        const port = portArg !== -1 ? parseInt(process.argv[portArg + 1], 10) : undefined;
+        const hostArg = process.argv.indexOf("--host");
+        const host = hostArg !== -1 ? process.argv[hostArg + 1] : undefined;
+        import("./mcp-server.js").then(({ startServer }) => {
+            startServer({ port, host }).catch((err) => {
+                console.error("[hicortex] Server failed to start:", err);
+                process.exit(1);
+            });
+        });
+        break;
+    }
+    case "init":
+        import("./init.js").then(({ runInit }) => {
+            runInit().catch((err) => {
+                console.error("[hicortex] Init failed:", err);
+                process.exit(1);
+            });
+        });
+        break;
+    case "nightly": {
+        const dryRun = process.argv.includes("--dry-run");
+        import("./nightly.js").then(({ runNightly }) => {
+            runNightly({ dryRun }).catch((err) => {
+                console.error("[hicortex] Nightly pipeline failed:", err);
+                process.exit(1);
+            });
+        });
+        break;
+    }
+    case "status":
+        import("./status.js").then(({ runStatus }) => {
+            runStatus().catch((err) => {
+                console.error("[hicortex] Status failed:", err);
+                process.exit(1);
+            });
+        });
+        break;
+    case "uninstall":
+        import("./uninstall.js").then(({ runUninstall }) => {
+            runUninstall().catch((err) => {
+                console.error("[hicortex] Uninstall failed:", err);
+                process.exit(1);
+            });
+        });
+        break;
+    default:
+        console.log(`Hicortex — Human-like memory for self-improving AI agents
+
+Usage: hicortex <command> [options]
+
+Commands:
+  server     Start the MCP HTTP/SSE server
+  init       Set up Hicortex for Claude Code
+  nightly    Run nightly distill + consolidate + inject
+  status     Show current configuration and stats
+  uninstall  Remove CC integration (preserves DB)
+
+Options:
+  server --port <n>   Port (default: 8787)
+  server --host <h>   Host (default: 127.0.0.1)
+
+Examples:
+  npx @gamaze/hicortex server
+  npx @gamaze/hicortex init
+  npx @gamaze/hicortex status`);
+        process.exit(command ? 1 : 0);
+}

package/dist/consolidate.js

@@ -49,7 +49,7 @@ const node_os_1 = require("node:os");
 const retrieval_js_1 = require("./retrieval.js");
 const storage = __importStar(require("./storage.js"));
 const prompts_js_1 = require("./prompts.js");
-const LAST_CONSOLIDATED_PATH = (0, node_path_1.join)((0, node_os_1.homedir)(), ".claude", "memory", "last-consolidated.txt");
+const LAST_CONSOLIDATED_PATH = (0, node_path_1.join)((0, node_os_1.homedir)(), ".hicortex", "last-consolidated.txt");
 // Default config constants (matching Python config.py)
 const CONSOLIDATE_MAX_LLM_CALLS = 200;
 const CONSOLIDATE_PRUNE_MIN_AGE_DAYS = 90;

package/dist/db.d.ts

@@ -3,6 +3,16 @@
  * Ported from hicortex/db.py — same schema for migration compatibility.
  */
 import Database from "better-sqlite3";
+/**
+ * Resolve the database path. Handles migration from legacy OC location.
+ *
+ * Priority:
+ * 1. Explicit override (env var or config)
+ * 2. Canonical ~/.hicortex/hicortex.db (if exists)
+ * 3. Legacy ~/.openclaw/data/hicortex.db (migrate to canonical, leave symlink)
+ * 4. Default: create ~/.hicortex/hicortex.db
+ */
+export declare function resolveDbPath(override?: string): string;
 /**
  * Initialize the database: load sqlite-vec, enable WAL, create all tables.
  * Returns the open Database instance (caller manages lifetime).

package/dist/db.js

@@ -7,11 +7,85 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveDbPath = resolveDbPath;
 exports.initDb = initDb;
 exports.getStats = getStats;
 const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
 const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_os_1 = require("node:os");
 const EMBEDDING_DIMENSIONS = 384;
+/** Canonical Hicortex home directory. */
+const HICORTEX_HOME = (0, node_path_1.join)((0, node_os_1.homedir)(), ".hicortex");
+/** Legacy OC plugin DB path (pre-v0.3 installations). */
+const LEGACY_OC_DB = (0, node_path_1.join)((0, node_os_1.homedir)(), ".openclaw", "data", "hicortex.db");
+/**
+ * Resolve the database path. Handles migration from legacy OC location.
+ *
+ * Priority:
+ * 1. Explicit override (env var or config)
+ * 2. Canonical ~/.hicortex/hicortex.db (if exists)
+ * 3. Legacy ~/.openclaw/data/hicortex.db (migrate to canonical, leave symlink)
+ * 4. Default: create ~/.hicortex/hicortex.db
+ */
+function resolveDbPath(override) {
+    // 1. Explicit override
+    if (override)
+        return override;
+    const envOverride = process.env.HICORTEX_DB_PATH;
+    if (envOverride)
+        return envOverride;
+    const canonicalPath = (0, node_path_1.join)(HICORTEX_HOME, "hicortex.db");
+    // 2. Canonical path exists — use it
+    if ((0, node_fs_1.existsSync)(canonicalPath)) {
+        if ((0, node_fs_1.existsSync)(LEGACY_OC_DB) && !isSymlink(LEGACY_OC_DB)) {
+            console.warn(`[hicortex] WARNING: DB exists at both ${canonicalPath} and ${LEGACY_OC_DB}. ` +
+                `Using canonical path. Remove the legacy file if it is stale.`);
+        }
+        return canonicalPath;
+    }
+    // 3. Legacy OC path exists — migrate
+    if ((0, node_fs_1.existsSync)(LEGACY_OC_DB)) {
+        return migrateDb(LEGACY_OC_DB, canonicalPath);
+    }
+    // 4. Fresh install — ensure directory exists
+    (0, node_fs_1.mkdirSync)(HICORTEX_HOME, { recursive: true });
+    return canonicalPath;
+}
+/**
+ * Migrate DB from legacy path to canonical ~/.hicortex/.
+ * Moves the main DB file plus WAL/SHM if present.
+ * Leaves a symlink at the old path for backward compatibility.
+ */
+function migrateDb(legacyPath, canonicalPath) {
+    (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(canonicalPath), { recursive: true });
+    // Move main DB file
+    (0, node_fs_1.renameSync)(legacyPath, canonicalPath);
+    // Move WAL and SHM files if present
+    for (const suffix of ["-wal", "-shm"]) {
+        const legacySuffix = legacyPath + suffix;
+        if ((0, node_fs_1.existsSync)(legacySuffix)) {
+            (0, node_fs_1.renameSync)(legacySuffix, canonicalPath + suffix);
+        }
+    }
+    // Leave symlink at old path for backward compat
+    try {
+        (0, node_fs_1.symlinkSync)(canonicalPath, legacyPath);
+    }
+    catch {
+        // Non-fatal — symlink may fail on some filesystems
+    }
+    console.log(`[hicortex] Migrated database to ${canonicalPath}`);
+    return canonicalPath;
+}
+function isSymlink(path) {
+    try {
+        return (0, node_fs_1.lstatSync)(path).isSymbolicLink();
+    }
+    catch {
+        return false;
+    }
+}
 const SCHEMA = `
 CREATE TABLE IF NOT EXISTS memories (
     id TEXT PRIMARY KEY,

package/dist/index.js

@@ -41,11 +41,10 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 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_fs_1 = require("node:fs");
 const node_os_1 = require("node:os");
 const embedder_js_1 = require("./embedder.js");
 const storage = __importStar(require("./storage.js"));
@@ -78,11 +77,8 @@ exports.default = {
                 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");
+                // Resolve database path (handles migration from legacy OC location)
+                const dbPath = (0, db_js_1.resolveDbPath)(config.dbPath);
                 log(`[hicortex] Initializing database at ${dbPath}`);
                 db = (0, db_js_1.initDb)(dbPath);
                 // Auto-configure LLM: resolve → test → persist
@@ -213,7 +209,7 @@ exports.default = {
                 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 lastPath = joinPath(homeDir(), ".hicortex", "last-consolidated.txt");
                 const lastTs = readFs(lastPath, "utf-8").trim();
                 const lastDate = new Date(lastTs);
                 const hoursSince = (Date.now() - lastDate.getTime()) / (1000 * 60 * 60);
@@ -422,7 +418,7 @@ async function autoConfigureLlm(pluginConfig, log) {
 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 raw = (0, node_fs_1.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;
@@ -448,7 +444,7 @@ function persistProviderConfig(llmConfig, log) {
                     maxTokens: 8192,
                 }];
         }
-        (0, node_fs_2.writeFileSync)(configPath, JSON.stringify(config, null, 2));
+        (0, node_fs_1.writeFileSync)(configPath, JSON.stringify(config, null, 2));
         log(`[hicortex] Persisted LLM config: ${llmConfig.provider} → ${llmConfig.baseUrl}`);
     }
     catch {
@@ -462,14 +458,14 @@ function persistProviderConfig(llmConfig, log) {
 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 ts = (0, node_fs_1.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());
+            (0, node_fs_1.writeFileSync)(capFile, new Date().toISOString());
         }
         catch { /* non-fatal */ }
         return 0;
@@ -488,7 +484,7 @@ const HICORTEX_TOOLS = [
 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 raw = (0, node_fs_1.readFileSync)(configPath, "utf-8");
         const config = JSON.parse(raw);
         if (!config.tools)
             config.tools = {};
@@ -498,7 +494,7 @@ function ensureToolsAllowed(log) {
         if (missing.length === 0)
             return;
         config.tools.allow.push(...missing);
-        (0, node_fs_2.writeFileSync)(configPath, JSON.stringify(config, null, 2));
+        (0, node_fs_1.writeFileSync)(configPath, JSON.stringify(config, null, 2));
         log(`[hicortex] Added tools to allow list: ${missing.join(", ")}`);
     }
     catch {

package/dist/init.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Hicortex init — detect existing setup and configure for CC.
+ *
+ * Detection:
+ *   1. Local HC server running (localhost:8787)
+ *   2. Remote HC server (HICORTEX_SERVER_URL or bedrock:8787)
+ *   3. OC plugin installed (~/.openclaw/openclaw.json)
+ *   4. CC MCP already registered (~/.claude/settings.json)
+ *   5. Existing DB (~/.hicortex/ or ~/.openclaw/data/)
+ *
+ * Actions:
+ *   - Install persistent daemon (launchd/systemd)
+ *   - Register MCP server in CC settings
+ *   - Inject CLAUDE.md learnings block
+ *   - Install CC custom commands (/learn, /hicortex-activate)
+ */
+export declare function runInit(): Promise<void>;