@gamaze/hicortex 0.3.17 → 0.4.0

package/README.md

@@ -1,137 +1,159 @@
-# @gamaze/hicortex — Human-like Memory for Self-Improving AI Agents
+# @gamaze/hicortex — Self-Learning Memory for AI Agents
 
-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.
+Your agents learn from every session — successes and mistakes. Hicortex captures experiences, distills lessons, and applies them automatically. Connect multiple agents to shared memory and they improve together, overnight.
 
-Works with **OpenClaw** (in-process plugin) and **Claude Code** (HTTP/SSE MCP server).
+Works with **Claude Code** (primary), **OpenClaw** (in-process plugin), and any MCP-compatible agent.
 
-## Requirements
+**Website:** [hicortex.gamaze.com](https://hicortex.gamaze.com) · **Docs:** [hicortex.gamaze.com/docs](https://hicortex.gamaze.com/docs/)
 
-- Node.js 18+
-- LLM provider (auto-detected from OC config or `ANTHROPIC_API_KEY` for CC)
-- ~500MB disk for database + embedding model
-
-## Install — OpenClaw
+## Install — Server Mode (single machine)
 
 ```bash
-openclaw plugins install @gamaze/hicortex
-openclaw gateway restart
+npx @gamaze/hicortex init
 ```
 
-No configuration needed. The plugin auto-detects your LLM provider from OpenClaw settings on first startup.
+Detects your environment, installs a persistent MCP server daemon, auto-detects Ollama/Claude CLI/API keys, and registers with Claude Code. One command.
 
-## Install — Claude Code
+## Install — Client Mode (multi-client)
 
 ```bash
-npx @gamaze/hicortex init
+npx @gamaze/hicortex init --server https://your-server.example.com
 ```
 
-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.
+Connects to a remote Hicortex server. Sessions are distilled locally (privacy), memories are sent to the shared server. No local database needed.
 
-Or manually:
+## Install — OpenClaw
 
 ```bash
-# Start server
-npx @gamaze/hicortex server
-
-# Register with CC
-claude mcp add hicortex --transport http http://localhost:8787/sse
+openclaw plugins install @gamaze/hicortex
+openclaw gateway restart
 ```
 
-## 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 |
-| `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 |
+## Requirements
 
-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.
+- Node.js 18+
+- LLM: Ollama 9b+ (recommended), Claude CLI, or API key (Anthropic, OpenAI, etc.)
+- ~500MB disk for database + embedding model
 
 ## What Happens Automatically
 
 | When | What | How |
 |------|------|-----|
-| 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 start | Recent lessons injected into context | CLAUDE.md block / OC hook |
+| Agent end | Conversation captured | CC: nightly transcript scan / OC: hook |
+| Nightly | Distill → score → reflect → link → inject | Automatic pipeline |
 
-## Agent Tools
+## Agent Tools (MCP)
 
-Available via MCP (both OC and CC):
+6 tools available via MCP:
 
-- **hicortex_search** — Semantic search across all stored knowledge
+- **hicortex_search** — Semantic search across all stored memories
 - **hicortex_context** — Get recent decisions and project state
-- **hicortex_ingest** — Store a piece of knowledge directly
+- **hicortex_ingest** — Store a memory directly
 - **hicortex_lessons** — Get actionable lessons from reflection
+- **hicortex_update** — Fix incorrect memories (re-embeds on content change)
+- **hicortex_delete** — Remove memories with cascade cleanup
 
 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)
+npx @gamaze/hicortex server                    # Start MCP server (port 8787)
+npx @gamaze/hicortex init                      # Set up server mode
+npx @gamaze/hicortex init --server <url>       # Set up client mode
+npx @gamaze/hicortex nightly                   # Run distill + consolidate
+npx @gamaze/hicortex nightly --dry-run         # Preview without changes
+npx @gamaze/hicortex status                    # Show config, DB stats
+npx @gamaze/hicortex uninstall                 # Remove CC integration (keeps DB)
 ```
 
 ## Architecture
 
 ```
-@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
+  Client (MBP)              Server (bedrock)          Client (MBA)
+  ┌──────────┐              ┌──────────────┐          ┌──────────┐
+  │CC sessions│              │   Shared DB   │          │CC sessions│
+  │    ↓      │  POST        │              │  POST    │    ↓      │
+  │ Distill   │──/ingest───→│  Embed+Store  │←/ingest──│ Distill   │
+  │ (local)   │              │      ↓       │          │ (local)   │
+  │           │  MCP         │ Consolidate  │   MCP    │           │
+  │    CC    ←│──(search)───│ (score,link,  │──(search)→│   CC     │
+  │           │              │  reflect)    │          │           │
+  └──────────┘              └──────────────┘          └──────────┘
 
 Shared core:
-  ├── SQLite + sqlite-vec + FTS5 (single file)
+  ├── SQLite + sqlite-vec + FTS5
   ├── bge-small-en-v1.5 embeddings (ONNX, local CPU)
-  ├── BM25 + vector search with RRF fusion
-  └── Multi-provider LLM (20+ providers)
+  ├── BM25 + vector search with RRF fusion + graph traversal
+  └── Multi-provider LLM (Ollama, Claude CLI, 20+ cloud providers)
 ```
 
-## Database
+## Configuration
 
-Canonical location: `~/.hicortex/hicortex.db`. Existing OC installations at `~/.openclaw/data/hicortex.db` are automatically migrated on upgrade.
+Config at `~/.hicortex/config.json`. Created by `init`. Key options:
+
+| Field | Description |
+|-------|-------------|
+| `mode` | `"server"` (default) or `"client"` |
+| `serverUrl` | Remote server URL (client mode) |
+| `llmModel` | Model for importance scoring |
+| `distillModel` | Model for session distillation (9b+ recommended) |
+| `reflectModel` | Model for nightly reflection (largest available) |
+| `reflectBaseUrl` | Separate Ollama instance for reflection |
+| `authToken` | Bearer token for endpoint auth |
+| `licenseKey` | License key for higher tiers |
+
+Full docs: [hicortex.gamaze.com/docs/configuration.html](https://hicortex.gamaze.com/docs/configuration.html)
+
+## REST API
+
+| Endpoint | Method | Auth | Description |
+|----------|--------|------|-------------|
+| `/health` | GET | No | Server status, memory count, version |
+| `/ingest` | POST | Yes | Accept pre-distilled memories from clients |
+| `/sse` | GET | Yes | MCP SSE stream for agent connections |
+| `/messages` | POST | Yes | MCP message endpoint |
 
 ## Pricing
 
-| Tier | Price | Memories | Features |
-|------|-------|----------|----------|
-| Free | $0 | 250 | Full features: search, reflection, lessons, linking |
-| Pro | $9/month | Unlimited | Everything in Free, unlimited |
-| Lifetime | $149 | Unlimited | Pro forever |
-| Team | $29/month | Unlimited | Multi-agent shared memory |
+| Tier | Price | Memories | Clients |
+|------|-------|----------|---------|
+| Free | $0 | 250 | Unlimited (trial) |
+| Pro | $9/month | Unlimited | Single |
+| Team | $29/month | Unlimited | Unlimited |
+| Lifetime | $149 | Unlimited | Single |
 
-Get a license key at [hicortex.gamaze.com](https://hicortex.gamaze.com).
+[hicortex.gamaze.com](https://hicortex.gamaze.com)
 
 ## Uninstall
 
-**OpenClaw:**
 ```bash
-openclaw plugins uninstall hicortex
+npx @gamaze/hicortex uninstall    # Claude Code
+openclaw plugins uninstall hicortex  # OpenClaw
 ```
 
-**Claude Code:**
-```bash
-npx @gamaze/hicortex uninstall
-```
+Database preserved by default. Remove all data: `rm -rf ~/.hicortex`
 
-Your memory database is preserved by default. To remove all data: `rm -rf ~/.hicortex`
+## Configure — OpenClaw
+
+Optional config (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 |
+| `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 |
+
+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.
+
+## Database
+
+Canonical location: `~/.hicortex/hicortex.db`. Existing OC installations at `~/.openclaw/data/hicortex.db` are automatically migrated on upgrade.
 
 ## Development
 
@@ -152,6 +174,8 @@ npm test
 
 **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`.
+**Server won't start (CC):** Check `~/.hicortex/nightly.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.
+
+**Ollama timeout on large sessions:** Hicortex uses streaming mode with 3 retries (30s, 60s, 120s backoff). If first call fails (model loading), retry handles it automatically.

package/dist/cli.js

@@ -26,14 +26,17 @@ switch (command) {
         });
         break;
     }
-    case "init":
+    case "init": {
+        const serverArg = process.argv.indexOf("--server");
+        const serverUrl = serverArg !== -1 ? process.argv[serverArg + 1] : undefined;
         import("./init.js").then(({ runInit }) => {
-            runInit().catch((err) => {
+            runInit({ serverUrl }).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 }) => {
@@ -66,8 +69,9 @@ switch (command) {
 Usage: hicortex <command> [options]
 
 Commands:
-  server     Start the MCP HTTP/SSE server
-  init       Set up Hicortex for Claude Code
+  server     Start the MCP HTTP/SSE server (server mode)
+  init       Set up Hicortex (server mode, local DB + daemon)
+  init --server <url>  Set up as client (remote server, local distillation)
   nightly    Run nightly distill + consolidate + inject
   status     Show current configuration and stats
   uninstall  Remove CC integration (preserves DB)
@@ -75,10 +79,12 @@ Commands:
 Options:
   server --port <n>   Port (default: 8787)
   server --host <h>   Host (default: 127.0.0.1)
+  nightly --dry-run   Preview without changes
 
 Examples:
   npx @gamaze/hicortex server
   npx @gamaze/hicortex init
+  npx @gamaze/hicortex init --server https://myserver.example.com
   npx @gamaze/hicortex status`);
         process.exit(command ? 1 : 0);
 }

package/dist/consolidate.js

@@ -228,7 +228,12 @@ async function stageReflection(db, memories, llm, budget, embedFn, dryRun) {
         return `[${project}] [${agent}] ${content}`;
     });
     const memoriesBlock = lines.join("\n\n");
-    const prompt = (0, prompts_js_1.reflection)(memoriesBlock);
+    // Feed recent lessons to prevent duplicates and enable escalation
+    const recentLessons = storage.getLessons(db, 7).slice(0, 10);
+    const recentBlock = recentLessons.length > 0
+        ? recentLessons.map(l => `- ${l.content.slice(0, 150)}`).join("\n")
+        : undefined;
+    const prompt = (0, prompts_js_1.reflection)(memoriesBlock, recentBlock);
     if (dryRun) {
         return { lessons_generated: 0, skipped: false };
     }
@@ -250,10 +255,12 @@ async function stageReflection(db, memories, llm, budget, embedFn, dryRun) {
             if (!lessonText)
                 continue;
             const project = String(lo.project ?? "global");
+            const lessonType = String(lo.type ?? "principle");
             const severity = String(lo.severity ?? "important");
             const confidence = String(lo.confidence ?? "medium");
             const sourcePattern = String(lo.source_pattern ?? "");
             let content = `## Lesson: ${lessonText}\n\n`;
+            content += `**Type:** ${lessonType}\n`;
             content += `**Severity:** ${severity}\n`;
             content += `**Confidence:** ${confidence}\n`;
             if (sourcePattern)

package/dist/init.d.ts

@@ -14,4 +14,6 @@
  *   - Inject CLAUDE.md learnings block
  *   - Install CC custom commands (/learn, /hicortex-activate)
  */
-export declare function runInit(): Promise<void>;
+export declare function runInit(options?: {
+    serverUrl?: string;
+}): Promise<void>;

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);

package/dist/nightly.js

@@ -96,8 +96,14 @@ function writeLastRun() {
 }
 async function runNightly(options = {}) {
     const dryRun = options.dryRun ?? false;
-    const dbPath = (0, db_js_1.resolveDbPath)(options.dbPath);
     const stateDir = options.stateDir ?? HICORTEX_HOME;
+    // Check mode: client or server
+    const savedConfig = readNightlyConfig(stateDir);
+    if (savedConfig?.mode === "client") {
+        await runClientNightly(savedConfig, dryRun);
+        return;
+    }
+    const dbPath = (0, db_js_1.resolveDbPath)(options.dbPath);
     console.log(`[hicortex] Nightly pipeline starting${dryRun ? " (dry run)" : ""}`);
     console.log(`[hicortex] DB: ${dbPath}`);
     // Init DB
@@ -116,18 +122,43 @@ async function runNightly(options = {}) {
             }
             else {
                 console.warn("[hicortex] claude-cli configured but binary not found, falling back");
-                llmConfig = (0, llm_js_1.resolveLlmConfigForCC)();
+                llmConfig = (0, llm_js_1.resolveLlmConfigForCC)({
+                    llmBaseUrl: savedConfig?.llmBaseUrl,
+                    llmApiKey: savedConfig?.llmApiKey,
+                    llmModel: savedConfig?.llmModel,
+                    reflectModel: savedConfig?.reflectModel,
+                });
             }
         }
+        else if (savedConfig?.llmBackend === "ollama") {
+            llmConfig = {
+                baseUrl: savedConfig.llmBaseUrl ?? "http://localhost:11434",
+                apiKey: "",
+                model: savedConfig.llmModel ?? "qwen3.5:4b",
+                reflectModel: savedConfig.reflectModel ?? savedConfig.llmModel ?? "qwen3.5:4b",
+                provider: "ollama",
+            };
+        }
         else {
             llmConfig = (0, llm_js_1.resolveLlmConfigForCC)({
                 llmBaseUrl: savedConfig?.llmBaseUrl,
                 llmApiKey: savedConfig?.llmApiKey,
                 llmModel: savedConfig?.llmModel,
+                reflectModel: savedConfig?.reflectModel,
             });
         }
+        // Apply distillModel and reflect overrides from config
+        if (savedConfig?.distillModel) {
+            llmConfig.distillModel = savedConfig.distillModel;
+        }
+        if (savedConfig?.reflectBaseUrl) {
+            llmConfig.reflectBaseUrl = savedConfig.reflectBaseUrl;
+            llmConfig.reflectApiKey = savedConfig.reflectApiKey ?? llmConfig.apiKey;
+            llmConfig.reflectProvider = savedConfig.reflectProvider ?? llmConfig.provider;
+        }
         const llm = new llm_js_1.LlmClient(llmConfig);
-        console.log(`[hicortex] LLM: ${llmConfig.provider}/${llmConfig.model}`);
+        const distillInfo = llmConfig.distillModel ? `, distill: ${llmConfig.distillModel}` : "";
+        console.log(`[hicortex] LLM: ${llmConfig.provider}/${llmConfig.model}${distillInfo}`);
         // Step 1: Read new CC transcripts
         const since = readLastRun();
         console.log(`[hicortex] Reading CC transcripts since ${since.toISOString()}`);
@@ -206,3 +237,141 @@ async function runNightly(options = {}) {
         db.close();
     }
 }
+// ---------------------------------------------------------------------------
+// Client Mode Nightly — distill locally, POST to remote server
+// ---------------------------------------------------------------------------
+async function runClientNightly(config, dryRun) {
+    const serverUrl = config.serverUrl.replace(/\/+$/, "");
+    const authToken = config.authToken;
+    console.log(`[hicortex] Client nightly starting${dryRun ? " (dry run)" : ""}`);
+    console.log(`[hicortex] Server: ${serverUrl}`);
+    // Verify server is reachable
+    try {
+        const resp = await fetch(`${serverUrl}/health`, { signal: AbortSignal.timeout(5000) });
+        if (!resp.ok)
+            throw new Error(`HTTP ${resp.status}`);
+        const data = await resp.json();
+        console.log(`[hicortex] Server OK: v${data.version}, ${data.memories} memories`);
+    }
+    catch (err) {
+        console.error(`[hicortex] Server unreachable at ${serverUrl}: ${err instanceof Error ? err.message : String(err)}`);
+        console.error(`[hicortex] Aborting. Will retry next run.`);
+        return; // Don't update last-run so we retry
+    }
+    // Init LLM for local distillation
+    let llmConfig;
+    if (config.llmBackend === "claude-cli") {
+        const claudePath = (0, llm_js_1.findClaudeBinary)();
+        if (claudePath) {
+            llmConfig = (0, llm_js_1.claudeCliConfig)(claudePath);
+        }
+        else {
+            llmConfig = (0, llm_js_1.resolveLlmConfigForCC)();
+        }
+    }
+    else if (config.llmBackend === "ollama") {
+        llmConfig = {
+            baseUrl: config.llmBaseUrl ?? "http://localhost:11434",
+            apiKey: "",
+            model: config.llmModel ?? "qwen3.5:4b",
+            reflectModel: config.reflectModel ?? config.llmModel ?? "qwen3.5:4b",
+            provider: "ollama",
+        };
+    }
+    else {
+        llmConfig = (0, llm_js_1.resolveLlmConfigForCC)({
+            llmBaseUrl: config.llmBaseUrl,
+            llmApiKey: config.llmApiKey,
+            llmModel: config.llmModel,
+        });
+    }
+    if (config.distillModel) {
+        llmConfig.distillModel = config.distillModel;
+    }
+    const llm = new llm_js_1.LlmClient(llmConfig);
+    console.log(`[hicortex] LLM: ${llmConfig.provider}/${llmConfig.distillModel ?? llmConfig.model}`);
+    // Read new CC transcripts
+    const since = readLastRun();
+    console.log(`[hicortex] Reading CC transcripts since ${since.toISOString()}`);
+    const batches = (0, transcript_reader_js_1.readCcTranscripts)(since);
+    console.log(`[hicortex] Found ${batches.length} new session(s)`);
+    if (batches.length === 0) {
+        console.log(`[hicortex] Nothing to distill.`);
+        if (!dryRun)
+            writeLastRun();
+        return;
+    }
+    // Distill each session and POST to server
+    let memoriesIngested = 0;
+    let sessionsSent = 0;
+    for (const batch of batches) {
+        const transcript = (0, distiller_js_1.extractConversationText)(batch.entries);
+        if (transcript.length < 200) {
+            console.log(`[hicortex]   Skip ${batch.sessionId.slice(0, 8)} (${batch.projectName}): too short`);
+            continue;
+        }
+        console.log(`[hicortex]   Distilling ${batch.sessionId.slice(0, 8)} (${batch.projectName}, ${batch.date})`);
+        if (dryRun) {
+            console.log(`[hicortex]     [dry-run] Would distill ${transcript.length} chars`);
+            continue;
+        }
+        try {
+            const entries = await (0, distiller_js_1.distillSession)(llm, transcript, batch.projectName, batch.date);
+            if (entries.length === 0) {
+                console.log(`[hicortex]     → No memories extracted`);
+                continue;
+            }
+            // POST each extracted memory to the server
+            let sessionCount = 0;
+            for (const entry of entries) {
+                const resp = await fetch(`${serverUrl}/ingest`, {
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/json",
+                        ...(authToken ? { "Authorization": `Bearer ${authToken}` } : {}),
+                    },
+                    body: JSON.stringify({
+                        content: entry,
+                        source_agent: `claude-code/${batch.projectName}`,
+                        project: batch.projectName,
+                        memory_type: "episode",
+                        privacy: "WORK",
+                        source_session: batch.sessionId,
+                        session_date: batch.date,
+                    }),
+                    signal: AbortSignal.timeout(30_000),
+                });
+                const result = await resp.json();
+                if (resp.status === 201) {
+                    sessionCount++;
+                    memoriesIngested++;
+                }
+                else if (result.skipped) {
+                    console.log(`[hicortex]     → Already ingested (${result.existing_count} existing)`);
+                    break;
+                }
+                else if (resp.status === 401) {
+                    console.error(`[hicortex]     Auth failed. Check authToken in ~/.hicortex/config.json`);
+                    return;
+                }
+                else if (resp.status === 429) {
+                    console.log(`[hicortex]     Server memory limit reached.`);
+                    return;
+                }
+                else {
+                    console.error(`[hicortex]     Ingest failed (${resp.status}): ${result.error}`);
+                }
+            }
+            if (sessionCount > 0) {
+                sessionsSent++;
+                console.log(`[hicortex]     → ${sessionCount} memories sent to server`);
+            }
+        }
+        catch (err) {
+            console.error(`[hicortex]     Failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    if (!dryRun)
+        writeLastRun();
+    console.log(`[hicortex] Client nightly complete: ${memoriesIngested} memories from ${sessionsSent} sessions → ${serverUrl}`);
+}

package/dist/prompts.d.ts

@@ -9,7 +9,7 @@ export declare function importanceScoring(memoriesBlock: string): string;
 /**
  * Reflection prompt. Takes a {memories_block} with today's memories.
  */
-export declare function reflection(memoriesBlock: string): string;
+export declare function reflection(memoriesBlock: string, recentLessons?: string): string;
 /**
  * Distillation prompt. Extracts knowledge from a session transcript.
  */

package/dist/prompts.js

@@ -32,33 +32,61 @@ No explanations. Just the JSON array.`;
 /**
  * Reflection prompt. Takes a {memories_block} with today's memories.
  */
-function reflection(memoriesBlock) {
-    return `You are a self-improvement analyst for a multi-agent AI system. Review today's memories and extract 1-3 actionable lessons.
+function reflection(memoriesBlock, recentLessons) {
+    const recentSection = recentLessons
+        ? `\nRECENT LESSONS (already generated — do NOT duplicate, but DO escalate if patterns recur):\n${recentLessons}\n`
+        : "";
+    return `You are a learning analyst for a multi-agent AI system. Review today's memories and extract actionable lessons from BOTH successes and failures.
 
-Quality over quantity. One genuine insight that prevents a future mistake is worth more than five restatements of what happened. Most days, 1-2 lessons is ideal. An empty array is fine if nothing warrants a lesson.
+Like human learning: we grow fastest when we reinforce what works AND correct what doesn't. A system that only learns from mistakes becomes overly cautious. A system that only learns from successes never improves. The combination multiplies.
 
-Prefer GLOBAL lessons (applicable across all projects and agents) over project-specific ones. Only mark a lesson as project-specific if it truly cannot generalize.
-
-Good lesson: "When modifying template files processed by sed, always verify ALL substitution targets by diffing the output — partial fixes cause silent failures on other deployments"
-Bad lesson: "The deploy script had a bug" (restatement, not actionable)
+Quality over quantity. 1-3 lessons is typical. An empty array [] is the CORRECT response when memories show routine competent work without noteworthy patterns, surprises, or friction. Do not manufacture lessons from nothing.
 
+LESSON TYPES:
+- "reinforce": An approach or strategy that worked well — repeat and spread it
+- "correct": A mistake, gap, or near-miss that should be avoided
+- "principle": A general insight derived from either success or failure
+${recentSection}
 TODAY'S MEMORIES:
 ${memoriesBlock}
 
+EXAMPLES:
+Good reinforce: "Bundling related changes into a single PR with clear narrative gets faster approval — apply for all refactors"
+Good reinforce: "When presenting multi-scenario analysis, show assumptions side-by-side so stakeholders evaluate trade-offs rather than reacting to isolated worst-cases"
+Good correct: "Always verify ALL substitution targets by diffing output — partial fixes cause silent failures"
+Good principle: "Gather evidence from logs before forming hypotheses — evidence-first debugging resolved issues 3x faster today"
+Bad lesson: "The deploy script had a bug" (restatement, not actionable)
+
 For each lesson, output a JSON object:
 - "lesson": Concise, actionable rule in imperative voice
-- "project": "global" unless genuinely project-specific
+- "type": "reinforce" | "correct" | "principle"
+- "project": "global" unless genuinely project-specific (project-specific lessons are still valuable)
 - "severity": "critical" | "important" | "minor"
 - "confidence": "high" | "medium" | "low"
-- "source_pattern": What triggered this (1 sentence)
+- "source_pattern": What triggered this (1 sentence, no personal data)
 
-Confidence:
-- "high": Pattern across multiple events, or clear mistake with obvious fix. Safe to auto-inject into agent instructions.
+Severity guide:
+- "critical": Near-misses that could have caused data loss or security breach, even if caught in time. Also: recurring patterns that keep appearing despite prior corrections.
+- "important": Clear cause-effect, likely to recur. Worth sharing across agents.
+- "minor": Useful optimization, single incident.
+
+Confidence guide:
+- "high": Pattern across multiple events, or clear cause-effect. Safe to auto-inject into agent instructions.
 - "medium": Single incident but likely to recur. Store but don't auto-propagate.
 - "low": Speculative. Store for retrieval only.
 
-Focus on: process gaps, repeated friction, silent failures, user corrections to agent behavior, cross-agent patterns.
-Skip: trivial actions, already-documented rules, one-off events.
+Focus on:
+- SUCCESSES: effective strategies, approaches the user validated, patterns that saved time, clean solutions
+- FAILURES: process gaps, repeated friction, silent failures, user corrections
+- OMISSIONS: things that should have been done but weren't (missing tests, unchecked code paths, forgotten follow-ups)
+- NEAR-MISSES: problems caught before damage — these deserve critical severity
+- CONTRADICTIONS: cases where something appeared to work but didn't, or agents reached opposite conclusions
+- CROSS-AGENT PATTERNS: same issue or success across different agents — especially high-value
+- PROCESS FEEDBACK: user feedback about the agent's approach/behavior, not just its output
+
+Privacy: Never include personal data (names, health, finances, credentials) in lesson text. Abstract to the process level.
+
+Skip: isolated trivial actions, already-documented rules. However, if multiple small successes form a consistent pattern of quality, extract that pattern as a reinforcement.
 
 Respond with a JSON array. Empty array [] is a valid response.`;
 }

package/dist/types.d.ts

@@ -99,6 +99,7 @@ export interface LicenseInfo {
         vectorSearch: boolean;
         maxMemories: number;
         crossAgent: boolean;
+        remoteIngest?: boolean;
     };
     email?: string;
     expires_at?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gamaze/hicortex",
-  "version": "0.3.17",
+  "version": "0.4.0",
   "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": {
@@ -35,6 +35,7 @@
     "node": ">=18"
   },
   "license": "UNLICENSED",
+  "homepage": "https://hicortex.gamaze.com",
   "repository": {
     "type": "git",
     "url": "https://github.com/mha33/hicortex.git",