@gamaze/hicortex 0.3.16 → 0.4.0

package/dist/init.js

@@ -316,67 +316,154 @@ async function persistLlmConfig() {
         console.log(`  ✓ LLM config already configured`);
         return;
     }
-    // Try auto-detect from environment
-    const hcKey = process.env.HICORTEX_LLM_API_KEY;
-    const hcUrl = process.env.HICORTEX_LLM_BASE_URL;
-    if (hcKey && hcUrl) {
-        config.llmApiKey = hcKey;
-        config.llmBaseUrl = hcUrl;
-        if (process.env.HICORTEX_LLM_MODEL)
-            config.llmModel = process.env.HICORTEX_LLM_MODEL;
-        saveConfig(configPath, config);
-        console.log(`  ✓ LLM config auto-detected from HICORTEX_LLM_* env vars`);
-        return;
+    // Auto-detect all available LLM options
+    const options = [];
+    // 1. Check Ollama (local models — best for privacy and quality)
+    const ollamaModels = detectOllamaModels();
+    if (ollamaModels.length > 0) {
+        // Pick the largest model — only recommend if >= 7GB (~7b+ parameter models)
+        const best = ollamaModels[0]; // already sorted by size desc
+        const goodEnough = best.sizeGb >= 7;
+        options.push({
+            label: `Ollama ${best.name} (local${best.sizeGb ? `, ${best.sizeGb}GB` : ""}${goodEnough ? "" : ", small model"})`,
+            recommended: goodEnough,
+            save: () => {
+                config.llmBackend = "ollama";
+                config.llmBaseUrl = "http://localhost:11434";
+                config.llmModel = best.name;
+                saveConfig(configPath, config);
+            },
+        });
+        // Add other models if available
+        for (const m of ollamaModels.slice(1, 3)) {
+            options.push({
+                label: `Ollama ${m.name} (local${m.sizeGb ? `, ${m.sizeGb}GB` : ""})`,
+                save: () => {
+                    config.llmBackend = "ollama";
+                    config.llmBaseUrl = "http://localhost:11434";
+                    config.llmModel = m.name;
+                    saveConfig(configPath, config);
+                },
+            });
+        }
     }
+    // 2. Check Claude CLI
+    const { findClaudeBinary } = await import("./llm.js");
+    const claudePath = findClaudeBinary();
+    if (claudePath) {
+        options.push({
+            label: "Claude CLI (subscription, Haiku model)",
+            recommended: ollamaModels.length === 0,
+            save: () => {
+                config.llmBackend = "claude-cli";
+                saveConfig(configPath, config);
+            },
+        });
+    }
+    // 3. Check env vars
     if (process.env.ANTHROPIC_API_KEY) {
-        config.llmApiKey = process.env.ANTHROPIC_API_KEY;
-        config.llmBaseUrl = process.env.ANTHROPIC_BASE_URL ?? "https://api.anthropic.com";
-        config.llmProvider = "anthropic";
-        saveConfig(configPath, config);
-        console.log(`  ✓ LLM config auto-detected from ANTHROPIC_API_KEY`);
-        return;
+        options.push({
+            label: "Anthropic API (from ANTHROPIC_API_KEY)",
+            save: () => {
+                config.llmApiKey = process.env.ANTHROPIC_API_KEY;
+                config.llmBaseUrl = process.env.ANTHROPIC_BASE_URL ?? "https://api.anthropic.com";
+                config.llmProvider = "anthropic";
+                saveConfig(configPath, config);
+            },
+        });
     }
-    // Try OC auth-profiles
+    if (process.env.OPENAI_API_KEY) {
+        options.push({
+            label: "OpenAI API (from OPENAI_API_KEY)",
+            save: () => {
+                config.llmApiKey = process.env.OPENAI_API_KEY;
+                config.llmBaseUrl = process.env.OPENAI_BASE_URL ?? "https://api.openai.com";
+                config.llmProvider = "openai";
+                saveConfig(configPath, config);
+            },
+        });
+    }
+    // 4. Check OC auth-profiles
     const ocLlm = readOcLlmConfig();
     if (ocLlm) {
-        config.llmApiKey = ocLlm.apiKey;
-        config.llmBaseUrl = ocLlm.baseUrl;
-        config.llmProvider = ocLlm.provider;
-        if (ocLlm.model)
-            config.llmModel = ocLlm.model;
-        saveConfig(configPath, config);
-        console.log(`  ✓ LLM config auto-detected from OpenClaw (${ocLlm.provider})`);
-        return;
+        options.push({
+            label: `OpenClaw (${ocLlm.provider}/${ocLlm.model ?? "default"})`,
+            save: () => {
+                config.llmApiKey = ocLlm.apiKey;
+                config.llmBaseUrl = ocLlm.baseUrl;
+                config.llmProvider = ocLlm.provider;
+                if (ocLlm.model)
+                    config.llmModel = ocLlm.model;
+                saveConfig(configPath, config);
+            },
+        });
     }
-    // Not auto-detected — ask the user
-    console.log("\n  LLM config not auto-detected. Hicortex needs an LLM for nightly learning.\n");
-    console.log("  How should Hicortex access an LLM?\n");
-    console.log("    1. Use Claude subscription via CLI (Haiku model, no API key needed)");
-    console.log("    2. Enter an API key manually (Anthropic, OpenAI, or other)");
-    console.log("    3. Cancel installation\n");
-    const choice = await ask("  Choice [1]: ");
-    const selected = choice === "2" ? 2 : choice === "3" ? 3 : 1;
-    if (selected === 1) {
-        config.llmBackend = "claude-cli";
-        saveConfig(configPath, config);
-        console.log(`  ✓ Configured to use Claude CLI (Haiku model via subscription)`);
-    }
-    else if (selected === 2) {
-        const apiKey = await ask("  API key: ");
-        if (!apiKey) {
-            console.log("  ⚠ No key entered. Skipping.");
-            return;
-        }
-        const baseUrl = await ask("  Base URL [https://api.anthropic.com]: ");
-        config.llmApiKey = apiKey;
-        config.llmBaseUrl = baseUrl || "https://api.anthropic.com";
-        config.llmProvider = "anthropic";
-        saveConfig(configPath, config);
-        console.log(`  ✓ API key saved`);
+    // 5. Always offer manual entry and cancel
+    options.push({
+        label: "Other provider (requires API key)",
+        save: async () => {
+            console.log("\n  Providers: Anthropic, OpenAI, Google, z.ai, OpenRouter, or any OpenAI-compatible");
+            const baseUrl = await ask("  Provider base URL: ");
+            if (!baseUrl) {
+                console.log("  ⚠ Cancelled.");
+                process.exit(0);
+            }
+            const apiKey = await ask("  API key: ");
+            if (!apiKey) {
+                console.log("  ⚠ Cancelled.");
+                process.exit(0);
+            }
+            const model = await ask("  Model name (optional): ");
+            config.llmApiKey = apiKey;
+            config.llmBaseUrl = baseUrl;
+            if (model)
+                config.llmModel = model;
+            saveConfig(configPath, config);
+        },
+    });
+    options.push({
+        label: "Cancel installation",
+        save: () => {
+            console.log("\n  Hicortex requires an LLM to function. Installation cancelled.");
+            process.exit(0);
+        },
+    });
+    // Find recommended index
+    const recommendedIdx = options.findIndex(o => o.recommended);
+    const defaultIdx = recommendedIdx >= 0 ? recommendedIdx : 0;
+    // Display
+    console.log("\n  LLM for nightly distillation:\n");
+    for (let i = 0; i < options.length; i++) {
+        const marker = i === defaultIdx ? " (recommended)" : "";
+        console.log(`    ${i + 1}. ${options[i].label}${marker}`);
+    }
+    const choice = await ask(`\n  Choice [${defaultIdx + 1}]: `);
+    const selected = choice ? parseInt(choice, 10) - 1 : defaultIdx;
+    if (selected < 0 || selected >= options.length) {
+        console.log("  Invalid choice.");
+        process.exit(1);
+    }
+    await options[selected].save();
+    console.log(`  ✓ LLM configured: ${options[selected].label}`);
+}
+function detectOllamaModels() {
+    try {
+        const resp = (0, node_child_process_1.execSync)("curl -s --max-time 2 http://localhost:11434/api/tags", {
+            encoding: "utf-8",
+            timeout: 3000,
+        });
+        const data = JSON.parse(resp);
+        const models = (data.models ?? [])
+            .filter((m) => !m.name.includes("embed")) // skip embedding models
+            .map((m) => ({
+            name: m.name,
+            sizeGb: Math.round((m.size ?? 0) / 1e9 * 10) / 10,
+        }))
+            .sort((a, b) => b.sizeGb - a.sizeGb); // largest first
+        return models;
     }
-    else {
-        console.log("\n  Hicortex requires an LLM to function. Installation cancelled.");
-        process.exit(0);
+    catch {
+        return [];
     }
 }
 function saveConfig(configPath, config) {
@@ -525,7 +612,11 @@ async function ask(question) {
 // ---------------------------------------------------------------------------
 // Main
 // ---------------------------------------------------------------------------
-async function runInit() {
+async function runInit(options = {}) {
+    if (options.serverUrl) {
+        await runClientInit(options.serverUrl);
+        return;
+    }
     console.log("Hicortex — Setup for Claude Code\n");
     // Phase 1: Detect
     console.log("Detecting existing setup...\n");
@@ -649,3 +740,232 @@ async function runInit() {
     console.log("  3. Try /learn to save something to long-term memory");
     console.log(`  4. Check server: curl ${serverUrl}/health`);
 }
+// ---------------------------------------------------------------------------
+// Client Mode Init
+// ---------------------------------------------------------------------------
+async function runClientInit(serverUrl) {
+    console.log("Hicortex — Client Mode Setup\n");
+    serverUrl = serverUrl.replace(/\/+$/, "");
+    // Step 1: Verify server is reachable
+    console.log(`Checking server at ${serverUrl}...`);
+    try {
+        const resp = await fetch(`${serverUrl}/health`, { signal: AbortSignal.timeout(5000) });
+        if (!resp.ok)
+            throw new Error(`HTTP ${resp.status}`);
+        const info = await resp.json();
+        console.log(`  ✓ Server: v${info.version}, ${info.memories} memories, LLM: ${info.llm}`);
+    }
+    catch (err) {
+        console.error(`  ✗ Cannot reach server at ${serverUrl}`);
+        console.error(`    ${err instanceof Error ? err.message : String(err)}`);
+        console.error(`\n  Make sure the Hicortex server is running and accessible.`);
+        process.exit(1);
+    }
+    // Step 2: Auth — try default token first, prompt only if rejected
+    const DEFAULT_AUTH_TOKEN = "hctx-default-token";
+    let authToken = DEFAULT_AUTH_TOKEN;
+    try {
+        const probe = await fetch(`${serverUrl}/ingest`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "Authorization": `Bearer ${DEFAULT_AUTH_TOKEN}`,
+            },
+            body: JSON.stringify({ content: "" }),
+            signal: AbortSignal.timeout(5000),
+        });
+        if (probe.status === 401) {
+            // Server uses a custom token — ask the user
+            const tokenAnswer = await ask("\nServer uses a custom auth token. Enter token: ");
+            authToken = tokenAnswer.trim();
+            if (!authToken) {
+                console.error("  ✗ Auth token required but not provided.");
+                process.exit(1);
+            }
+            // Verify
+            const verify = await fetch(`${serverUrl}/ingest`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    "Authorization": `Bearer ${authToken}`,
+                },
+                body: JSON.stringify({ content: "" }),
+                signal: AbortSignal.timeout(5000),
+            });
+            if (verify.status === 401) {
+                console.error("  ✗ Auth token rejected by server.");
+                process.exit(1);
+            }
+            console.log("  ✓ Custom auth token verified");
+        }
+        else {
+            console.log("  ✓ Server connected (default auth)");
+        }
+    }
+    catch {
+        // Probe failed but health passed — continue with default token
+    }
+    // Step 3: Configure LLM for local distillation
+    console.log("\nConfigure LLM for local session distillation:");
+    await persistLlmConfig();
+    // Step 4: Save client config
+    (0, node_fs_1.mkdirSync)(HICORTEX_HOME, { recursive: true });
+    const configPath = (0, node_path_1.join)(HICORTEX_HOME, "config.json");
+    let config = {};
+    try {
+        config = JSON.parse((0, node_fs_1.readFileSync)(configPath, "utf-8"));
+    }
+    catch { }
+    config.mode = "client";
+    config.serverUrl = serverUrl;
+    if (authToken)
+        config.authToken = authToken;
+    saveConfig(configPath, config);
+    console.log(`  ✓ Client config saved to ${configPath}`);
+    // Step 5: Register CC MCP pointing to remote server
+    if (authToken) {
+        // Write directly with auth header
+        const claudeJsonPath = (0, node_path_1.join)((0, node_os_1.homedir)(), ".claude.json");
+        let claudeConfig = {};
+        try {
+            claudeConfig = JSON.parse((0, node_fs_1.readFileSync)(claudeJsonPath, "utf-8"));
+        }
+        catch { }
+        if (!claudeConfig.mcpServers)
+            claudeConfig.mcpServers = {};
+        claudeConfig.mcpServers.hicortex = {
+            type: "sse",
+            url: `${serverUrl}/sse`,
+            headers: { "Authorization": `Bearer ${authToken}` },
+        };
+        (0, node_fs_1.writeFileSync)(claudeJsonPath, JSON.stringify(claudeConfig, null, 2));
+        console.log(`  ✓ Registered MCP server with auth`);
+    }
+    else {
+        registerCcMcp(serverUrl);
+    }
+    allowHicortexTools();
+    // Step 6: Install CC commands
+    installCcCommands();
+    // Step 7: Inject CLAUDE.md learnings block
+    const claudeMdPath = (0, node_path_1.join)((0, node_os_1.homedir)(), ".claude", "CLAUDE.md");
+    if (!(0, node_fs_1.existsSync)(claudeMdPath) || !(0, node_fs_1.readFileSync)(claudeMdPath, "utf-8").includes("HICORTEX-LEARNINGS")) {
+        (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(claudeMdPath), { recursive: true });
+        let content = "";
+        try {
+            content = (0, node_fs_1.readFileSync)(claudeMdPath, "utf-8");
+        }
+        catch { }
+        const block = [
+            "<!-- HICORTEX-LEARNINGS:START -->",
+            "## Hicortex Learnings",
+            "",
+            "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.",
+            "<!-- HICORTEX-LEARNINGS:END -->",
+        ].join("\n");
+        if (content.length > 0 && !content.endsWith("\n"))
+            content += "\n";
+        if (content.length > 0)
+            content += "\n";
+        content += block + "\n";
+        (0, node_fs_1.writeFileSync)(claudeMdPath, content);
+        console.log(`  ✓ Added Hicortex Learnings block`);
+    }
+    // Step 8: Install nightly cron (distill locally, POST to server)
+    installNightlyCron();
+    console.log("\n✓ Hicortex client setup complete!\n");
+    console.log("How it works:");
+    console.log("  • MCP tools (search, context, ingest) talk to the remote server");
+    console.log("  • Nightly pipeline distills CC transcripts locally, POSTs memories to server");
+    console.log("  • No local database — all memories stored on the server");
+    console.log(`\nServer: ${serverUrl}`);
+    console.log("Restart Claude Code to activate.");
+}
+function installNightlyCron() {
+    const npxPath = findNpxPath();
+    const packageSpec = getPackageSpec();
+    const os = (0, node_os_1.platform)();
+    if (os === "darwin") {
+        const plistDir = (0, node_path_1.join)((0, node_os_1.homedir)(), "Library", "LaunchAgents");
+        const plistPath = (0, node_path_1.join)(plistDir, "com.gamaze.hicortex-nightly.plist");
+        const logPath = (0, node_path_1.join)(HICORTEX_HOME, "nightly.log");
+        const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>com.gamaze.hicortex-nightly</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${npxPath}</string>
+    <string>-y</string>
+    <string>${packageSpec}</string>
+    <string>nightly</string>
+  </array>
+  <key>StartCalendarInterval</key>
+  <dict>
+    <key>Hour</key>
+    <integer>2</integer>
+    <key>Minute</key>
+    <integer>0</integer>
+  </dict>
+  <key>StandardOutPath</key>
+  <string>${logPath}</string>
+  <key>StandardErrorPath</key>
+  <string>${logPath}</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key>
+    <string>${(0, node_path_1.dirname)(npxPath)}:/usr/local/bin:/usr/bin:/bin</string>
+  </dict>
+</dict>
+</plist>`;
+        (0, node_fs_1.mkdirSync)(plistDir, { recursive: true });
+        (0, node_fs_1.writeFileSync)(plistPath, plist);
+        try {
+            try {
+                (0, node_child_process_1.execSync)(`launchctl unload ${plistPath} 2>/dev/null`, { stdio: "pipe" });
+            }
+            catch { }
+            (0, node_child_process_1.execSync)(`launchctl load ${plistPath}`, { stdio: "pipe" });
+            console.log(`  ✓ Installed nightly cron (runs daily at 02:00)`);
+        }
+        catch {
+            console.log(`  ⚠ Could not load nightly plist. Load manually: launchctl load ${plistPath}`);
+        }
+    }
+    else if (os === "linux") {
+        const configDir = (0, node_path_1.join)((0, node_os_1.homedir)(), ".config", "systemd", "user");
+        const servicePath = (0, node_path_1.join)(configDir, "hicortex-nightly.service");
+        const timerPath = (0, node_path_1.join)(configDir, "hicortex-nightly.timer");
+        const service = `[Unit]
+Description=Hicortex Nightly (distill + POST)
+
+[Service]
+Type=oneshot
+ExecStart=${npxPath} -y ${packageSpec} nightly
+Environment=PATH=/usr/local/bin:/usr/bin:/bin
+Environment=HOME=${(0, node_os_1.homedir)()}
+WorkingDirectory=${(0, node_os_1.homedir)()}`;
+        const timer = `[Unit]
+Description=Hicortex Nightly Timer
+
+[Timer]
+OnCalendar=*-*-* 02:00:00
+Persistent=true
+
+[Install]
+WantedBy=timers.target`;
+        (0, node_fs_1.mkdirSync)(configDir, { recursive: true });
+        (0, node_fs_1.writeFileSync)(servicePath, service);
+        (0, node_fs_1.writeFileSync)(timerPath, timer);
+        try {
+            (0, node_child_process_1.execSync)("systemctl --user daemon-reload", { stdio: "pipe" });
+            (0, node_child_process_1.execSync)("systemctl --user enable --now hicortex-nightly.timer", { stdio: "pipe" });
+            console.log(`  ✓ Installed nightly timer (runs daily at 02:00)`);
+        }
+        catch {
+            console.log(`  ⚠ Could not enable nightly timer. Enable manually: systemctl --user enable --now hicortex-nightly.timer`);
+        }
+    }
+}

package/dist/license.js

@@ -18,6 +18,7 @@ const FREE_LICENSE = {
         vectorSearch: true,
         maxMemories: 250,
         crossAgent: true,
+        remoteIngest: true,
     },
 };
 /** Validate a license key against the Hicortex API */

package/dist/llm.d.ts

@@ -89,6 +89,7 @@ export declare class LlmClient {
      */
     private completeWithOverride;
     private complete;
+    private completeOnce;
     /**
      * Claude CLI: shell out to `claude -p` for subscription users.
      * No API key needed — uses CC's authenticated session.

package/dist/llm.js

@@ -422,6 +422,28 @@ class LlmClient {
         if (this.isRateLimited) {
             throw new RateLimitError(this.rateLimitedUntil - Date.now());
         }
+        const retryDelays = [30_000, 60_000, 120_000]; // 30s, 60s, 120s
+        let lastErr;
+        for (let attempt = 0; attempt <= retryDelays.length; attempt++) {
+            try {
+                return await this.completeOnce(model, prompt, maxTokens, timeoutMs);
+            }
+            catch (err) {
+                lastErr = err instanceof Error ? err : new Error(String(err));
+                const msg = lastErr.message;
+                if (attempt < retryDelays.length && (msg.includes("fetch failed") || msg.includes("ECONNREFUSED") || msg.includes("timeout") || msg.includes("Headers Timeout"))) {
+                    const delay = retryDelays[attempt];
+                    console.log(`[hicortex] LLM call failed (${msg.slice(0, 60)}), retry ${attempt + 1}/${retryDelays.length} in ${delay / 1000}s...`);
+                    await new Promise(r => setTimeout(r, delay));
+                }
+                else {
+                    throw lastErr;
+                }
+            }
+        }
+        throw lastErr;
+    }
+    async completeOnce(model, prompt, maxTokens, timeoutMs) {
         if (this.config.provider === "claude-cli") {
             return this.completeClaude(model, prompt, timeoutMs);
         }
@@ -461,13 +483,15 @@ class LlmClient {
      */
     async completeOllama(model, prompt, maxTokens, timeoutMs) {
         const url = `${this.config.baseUrl.replace(/\/$/, "")}/api/generate`;
+        // Ollama can take minutes to process large contexts — use streaming to avoid
+        // Node.js fetch headers timeout (default ~300s kills long Ollama inferences)
         const resp = await fetch(url, {
             method: "POST",
             headers: { "Content-Type": "application/json" },
             body: JSON.stringify({
                 model,
                 prompt,
-                stream: false,
+                stream: true,
                 think: false,
                 options: { num_predict: maxTokens, num_ctx: 32768 },
             }),
@@ -478,12 +502,33 @@ class LlmClient {
         if (!resp.ok) {
             const text = await resp.text().catch(() => "");
             if (text.includes("1113") || text.includes("Insufficient balance")) {
-                this.handleRateLimit(resp); // z.ai/Ollama Cloud quota exceeded
+                this.handleRateLimit(resp);
             }
             throw new Error(`Ollama error ${resp.status}: ${text}`);
         }
-        const data = (await resp.json());
-        return (data.response ?? "").trim();
+        // Collect streamed response chunks
+        let result = "";
+        const reader = resp.body?.getReader();
+        if (!reader)
+            throw new Error("No response body");
+        const decoder = new TextDecoder();
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            const chunk = decoder.decode(value, { stream: true });
+            for (const line of chunk.split("\n")) {
+                if (!line.trim())
+                    continue;
+                try {
+                    const data = JSON.parse(line);
+                    if (data.response)
+                        result += data.response;
+                }
+                catch { /* skip malformed lines */ }
+            }
+        }
+        return result.trim();
     }
     /**
      * Anthropic Messages API (/v1/messages). Used for Anthropic and z.ai.

package/dist/mcp-server.js

@@ -308,10 +308,11 @@ async function startServer(options = {}) {
     const stats = (0, db_js_1.getStats)(db, dbPath);
     console.log(`[hicortex] Ready: ${stats.memories} memories, ${stats.links} links, ` +
         `${Math.round(stats.db_size_bytes / 1024)} KB`);
-    // Auth token: from options, config file, or env var
+    // Auth token: from config, env var, or default (always-on baseline security)
+    const DEFAULT_AUTH_TOKEN = "hctx-default-token";
     const authToken = savedConfig?.authToken
         ?? process.env.HICORTEX_AUTH_TOKEN
-        ?? "";
+        ?? DEFAULT_AUTH_TOKEN;
     // Express app
     const app = (0, express_1.default)();
     app.use(express_1.default.json());
@@ -360,6 +361,65 @@ async function startServer(options = {}) {
             llm: `${llmConfig.provider}/${llmConfig.model}`,
         });
     });
+    // REST /ingest — accept pre-distilled memories from remote clients
+    app.post("/ingest", async (req, res) => {
+        if (!db) {
+            res.status(503).json({ error: "Server not initialized" });
+            return;
+        }
+        // Pro license blocks remote ingest (upgrade to Team for multi-client)
+        const ip = req.ip ?? req.socket.remoteAddress ?? "";
+        const isLocal = ip === "127.0.0.1" || ip === "::1" || ip === "::ffff:127.0.0.1";
+        if (!isLocal) {
+            const features = (0, license_js_1.getFeatures)(stateDir);
+            if (features.remoteIngest === false) {
+                res.status(403).json({
+                    error: "Pro license is single-machine. Upgrade to Team for multi-client remote ingestion.",
+                    upgrade: "https://hicortex.gamaze.com/",
+                });
+                return;
+            }
+        }
+        const { content, source_agent, project, memory_type, privacy, source_session, session_date } = req.body ?? {};
+        if (!content || typeof content !== "string") {
+            res.status(400).json({ error: "Missing or invalid 'content' field" });
+            return;
+        }
+        const validTypes = ["episode", "lesson", "fact", "decision"];
+        if (memory_type && !validTypes.includes(memory_type)) {
+            res.status(400).json({ error: `Invalid memory_type: ${memory_type}` });
+            return;
+        }
+        // Dedup by source_session (idempotent — skip if already ingested)
+        if (source_session) {
+            const existing = db.prepare("SELECT COUNT(*) as cnt FROM memories WHERE source_session = ?").get(source_session);
+            if (existing.cnt > 0) {
+                res.status(200).json({ id: null, skipped: true, existing_count: existing.cnt });
+                return;
+            }
+        }
+        // License check
+        const features = (0, license_js_1.getFeatures)(stateDir);
+        if (features.maxMemories > 0 && storage.countMemories(db) >= features.maxMemories) {
+            res.status(429).json({ error: "Memory limit reached", limit: features.maxMemories });
+            return;
+        }
+        try {
+            const embedding = await (0, embedder_js_1.embed)(content);
+            const id = storage.insertMemory(db, content, embedding, {
+                sourceAgent: source_agent ?? "remote-client",
+                sourceSession: source_session ?? undefined,
+                project: project ?? undefined,
+                memoryType: memory_type ?? "episode",
+                privacy: privacy ?? "WORK",
+                createdAt: session_date ? new Date(session_date).toISOString() : undefined,
+            });
+            res.status(201).json({ id, message: "Memory ingested" });
+        }
+        catch (err) {
+            res.status(500).json({ error: "Ingestion failed", message: err instanceof Error ? err.message : String(err) });
+        }
+    });
     // SSE endpoint — each connection gets its own McpServer + transport
     app.get("/sse", async (req, res) => {
         const transport = new sse_js_1.SSEServerTransport("/messages", res);