memorix 0.4.1 → 0.5.1

package/CHANGELOG.md

@@ -1,6 +1,25 @@
 # Changelog
 
-## 0.1.0 (2026-02-14)
+All notable changes to this project will be documented in this file.
+
+## [0.5.0] — 2026-02-15
+
+### Added
+- **Antigravity Adapter**: Full support for Antigravity/Gemini IDE (MCP config + rules)
+- **Copilot Adapter**: VS Code Copilot MCP config adapter + rules format adapter
+- **Comprehensive Documentation**: 7 developer docs in `docs/` (Architecture, Modules, API Reference, Design Decisions, Development Guide, Known Issues & Roadmap, AI Context)
+- **8 new npm keywords**: antigravity, mcp-tool, memory-layer, ai-memory, progressive-disclosure, orama, vector-search, bm25
+- `prepublishOnly` now runs `npm test` in addition to build
+
+### Changed
+- README completely rewritten with clearer structure, npx zero-install setup, 6 agent configs, comparison table, Progressive Disclosure example, and architecture diagram
+- `description` field expanded for better npm search ranking
+- `files` array cleaned up (removed unused `examples` directory)
+
+### Fixed
+- 274 tests passing (up from 219), zero regressions
+
+## [0.1.0] — 2026-02-14
 
 ### Core
 - Knowledge Graph: Entity-Relation-Observation model (MCP Official compatible)

package/README.md

@@ -1,171 +1,212 @@
-# Memorix — Cross-Agent Memory Bridge
+<p align="center">
+  <h1 align="center">🧠 Memorix</h1>
+  <p align="center"><strong>Cross-Agent Memory Bridge — Universal memory layer for AI coding agents via MCP</strong></p>
+  <p align="center">
+    <a href="https://www.npmjs.com/package/memorix"><img src="https://img.shields.io/npm/v/memorix.svg?style=flat-square&color=cb3837" alt="npm version"></a>
+    <a href="https://www.npmjs.com/package/memorix"><img src="https://img.shields.io/npm/dm/memorix.svg?style=flat-square&color=blue" alt="npm downloads"></a>
+    <a href="LICENSE"><img src="https://img.shields.io/badge/license-Apache%202.0-green.svg?style=flat-square" alt="License"></a>
+    <a href="https://github.com/AVIDS2/memorix"><img src="https://img.shields.io/github/stars/AVIDS2/memorix?style=flat-square&color=yellow" alt="GitHub stars"></a>
+    <img src="https://img.shields.io/badge/tests-274%20passed-brightgreen?style=flat-square" alt="Tests">
+  </p>
+  <p align="center">
+    <a href="#-quick-start">Quick Start</a> •
+    <a href="#-features">Features</a> •
+    <a href="#-agent-configuration">Agent Config</a> •
+    <a href="#-how-it-works">How It Works</a> •
+    <a href="#-development">Development</a>
+  </p>
+</p>
+
+---
+
+> **Your AI forgot what you discussed yesterday? Not anymore.**
+>
+> Memorix stores and indexes project knowledge — architecture decisions, bug fixes, gotchas, code patterns — and exposes it via [MCP](https://modelcontextprotocol.io/) so **any AI coding agent** can access it. It also **syncs MCP configs, rules, skills, and workflows** across all your agents automatically.
+
+---
+
+## ⚡ Quick Start
+
+### 30-Second Setup (Zero Install)
+
+Add Memorix to your agent's MCP config — **that's it**. No global install needed.
+
+**Windsurf** → `~/.codeium/windsurf/mcp_config.json`
+```json
+{
+  "mcpServers": {
+    "memorix": {
+      "command": "npx",
+      "args": ["-y", "memorix@latest", "serve"]
+    }
+  }
+}
+```
 
-> Universal memory layer for AI coding agents via MCP
+Restart your agent and Memorix is running! 🎉
 
-[![npm version](https://img.shields.io/npm/v/memorix.svg)](https://www.npmjs.com/package/memorix)
-[![License](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](LICENSE)
+> 💡 More agent configs: [Cursor](#cursor) • [Claude Code](#claude-code) • [Codex](#codex) • [VS Code Copilot](#vs-code-copilot) • [Antigravity](#antigravity)
 
-## What is Memorix?
+### Or Install Globally
 
-Memorix is a lightweight local MCP server that acts as a **universal memory layer** across AI coding agents. Your knowledge from **Windsurf, Cursor, Claude Code, Codex, and VS Code Copilot** is stored once and shared everywhere.
+```bash
+npm install -g memorix
+```
 
-### The Problem
+Then use `"command": "memorix"` instead of `"command": "npx"` in your config.
 
-- claude-mem only serves Claude Code
-- mcp-memory-service has no cross-agent workspace sync
-- Your architecture decisions in Cursor are invisible to Claude Code
-- Bug fix knowledge in Windsurf doesn't transfer to Codex
-- **No one bridges memory AND workspace configs across agents**
+---
 
-### The Solution
+## 🤔 The Problem
 
-Memorix stores and indexes project knowledge (architecture decisions, bug fixes, code style preferences) and exposes it via MCP — so **any MCP-supporting agent** can access it. It also **syncs MCP configs, rules, skills, and workflows** across all your agents automatically.
+| Situation | Pain |
+|-----------|------|
+| Architecture decisions in Cursor | Invisible to Claude Code |
+| Bug fix knowledge in Windsurf | Doesn't transfer to Codex |
+| MCP server configs | Manually copy-paste between agents |
+| Agent rules & skills | Stuck in one IDE |
+| Start a new session | Re-explain everything from scratch |
 
-## Features
+**No one bridges memory AND workspace configs across agents — until now.**
 
-### P0 — Core (Current)
+---
 
-- **Knowledge Graph**: Entity-Relation model (MCP Official Memory Server compatible)
-- **3-Layer Progressive Disclosure**: Token-efficient search (claude-mem pattern)
-  - L1: Compact index (~50-100 tokens/result)
-  - L2: Timeline context
-  - L3: Full details on demand (~500-1000 tokens/result)
-- **9 Observation Types**: 🎯🔴🟡🔵🟢🟣🟠🟤⚖️
-- **Full-text Search**: Powered by Orama
-- **Per-project Isolation**: Auto-detected via Git remote
-- **MCP Compatible**: All 9 official Memory Server tools + 5 Memorix extensions
+## ✨ Features
 
-### P1 — Smart Search
+### 🧠 Smart Memory
 
-- **Hybrid Search**: Full-text (BM25) + Vector (semantic) via Orama
-- **Vector Embeddings**: Optional `fastembed` (local ONNX, zero API calls)
-- **Graceful Degradation**: No fastembed? Falls back to BM25 fulltext automatically
-- **Token Budget**: `maxTokens` parameter trims results to fit context windows
+- **Knowledge Graph** — Entity-Relation model, [MCP Official Memory Server](https://github.com/modelcontextprotocol/servers/tree/main/src/memory) compatible
+- **9 Observation Types** — 🎯 session-request 🔴 gotcha 🟡 problem-solution 🔵 how-it-works 🟢 what-changed 🟣 discovery 🟠 why-it-exists 🟤 decision ⚖️ trade-off
+- **Auto-Enrichment** — Automatically extracts file paths, module names, CamelCase identifiers from your narratives
+- **Auto-Relations** — Detects causal language ("because", "due to", "fixed by") and auto-creates typed graph relations
+- **Memory Decay** — Exponential decay scoring with immunity rules, so old memories fade while critical ones persist forever
 
-### P2 — Cross-Agent Workspace Sync
+### 🔍 Token-Efficient Search
 
-- **5 Agent Adapters**: Windsurf, Cursor, Claude Code, Codex, VS Code Copilot
-- **MCP Config Sync**: Detect and migrate MCP server configs across agents (merges into existing files — never overwrites)
-- **Rules Parser**: 4 format adapters (Cursor `.mdc`, Claude Code `CLAUDE.md`, Codex `SKILL.md`, Windsurf `.windsurfrules`)
-- **Rules Syncer**: Scan → Deduplicate → Conflict detection → Cross-format generation
-- **Skills Sync**: Scan `.codex/skills/`, `.cursor/skills/`, `.windsurf/skills/`, `.claude/skills/` → copy entire skill folders across agents
-- **Sync Advisory**: On first `memorix_search`, auto-detects available configs/skills from other agents and prompts the user
-- **Selective Sync**: Sync specific items by name (e.g. `items=["figma-remote-mcp-server", "create-subagent"]`)
-- **Apply with Safety**: Backup → Atomic write → Auto-rollback on failure
+- **3-Layer Progressive Disclosure** — Based on [claude-mem](https://github.com/anthropics/claude-code) (~10x token savings)
+  - **L1** `memorix_search` → Compact index (~50-100 tokens/result)
+  - **L2** `memorix_timeline` → Chronological context
+  - **L3** `memorix_detail` → Full details on demand (~500-1000 tokens/result)
+- **Hybrid Search** — Full-text (BM25) + Vector (semantic) via [Orama](https://github.com/orama/orama)
+- **Token Budget** — `maxTokens` parameter auto-trims results to fit context windows
 
-### P3 — Auto-Memory Hooks
+### 🔄 Cross-Agent Workspace Sync
 
-- **Hook Events**: `user_prompt`, `post_response`, `post_edit`, `post_command`, `post_tool`, `session_end`
-- **Agent Normalizer**: Maps Windsurf/Cursor/Claude Code/Codex native events to unified hook events
-- **Pattern Detection**: Auto-detects decisions, errors, gotchas, configurations, learnings, implementations
-- **Cooldown Filtering**: Prevents duplicate storage within configurable time windows
-- **Noise Filtering**: Skips trivial commands (`ls`, `cat`, `pwd`, etc.)
-- **Agent Rules**: Auto-installs `.windsurf/rules/memorix.md` (or equivalent) to guide agents in proactive memory management
-- **One-Command Install**: `memorix hooks install` sets up hooks + rules for your agent
+- **6 Agent Adapters** — Windsurf, Cursor, Claude Code, Codex, VS Code Copilot, Antigravity
+- **MCP Config Migration** — Detect and migrate MCP server configs (merges — never overwrites)
+- **Rules Sync** — Scan → Deduplicate → Conflict detection → Cross-format generation
+- **Skills & Workflows** — Copy skill folders and workflow files across agents
+- **Apply with Safety** — Backup `.bak` → Atomic write → Auto-rollback on failure
 
-### Context Continuity
+### 🪝 Auto-Memory Hooks
 
-- **Session Start**: Agent rules instruct AI to search memories before responding
-- **During Session**: Auto-capture decisions, bugs, gotchas via hooks + agent-driven `memorix_store`
-- **Session End**: Agent stores a "handoff note" summarizing progress and next steps
-- **Result**: Start a new session and your AI already knows everything — no re-explaining needed
+- **Implicit Memory** — Auto-captures decisions, errors, gotchas from agent activity
+- **Multi-Language Pattern Detection** — English + Chinese keyword matching
+- **Cooldown & Noise Filtering** — 30s cooldown, skips trivial commands (ls, cat, pwd)
+- **One-Command Install** — `memorix hooks install` sets up hooks + rules for your agent
 
-### P5 — Intelligence (Competitor-Inspired)
+### 🔁 Context Continuity
 
-- **Access Tracking**: `accessCount` + `lastAccessedAt` on every search hit (from mcp-memory-service)
-- **Memory Decay**: Exponential decay scoring `score = importance × e^(-age/retention) × accessBoost` (from mcp-memory-service)
-- **Retention Lifecycle**: Active → Stale → Archive-candidate with immunity rules (from MemCP)
-- **Entity Extraction**: Auto-extract files, modules, URLs, CamelCase identifiers from narratives (from MemCP)
-- **Auto-Enrichment**: `memorix_store` automatically enriches concepts and filesModified
-- **Causal Detection**: Detects "because/due to/caused by" patterns for typed relations
-- **Auto-Relations**: Implicit Knowledge Graph relation creation on store (causes/fixes/modifies)
-- **Typed Relations**: Recommended types: causes, fixes, supports, opposes, contradicts, depends_on
+```
+Session 1: You and AI discuss auth architecture
+  → Memorix auto-stores the decision
 
-## Quick Start
+Session 2: New chat, same project
+  → AI searches Memorix → "Ah, we decided on JWT with refresh tokens"
+  → No re-explaining needed!
+```
 
-### Install
+---
 
-```bash
-npm install -g memorix
-```
+## 🔧 Agent Configuration
 
-### Configure in your agent
+### Cursor
 
-**Windsurf** (`~/.codeium/windsurf/mcp_config.json`):
+`.cursor/mcp.json`:
 ```json
 {
   "mcpServers": {
     "memorix": {
-      "command": "memorix",
-      "args": ["serve"]
+      "command": "npx",
+      "args": ["-y", "memorix@latest", "serve"]
     }
   }
 }
 ```
 
-**Cursor** (`.cursor/mcp.json`):
-```json
-{
-  "mcpServers": {
-    "memorix": {
-      "command": "memorix",
-      "args": ["serve"]
-    }
-  }
-}
-```
+### Claude Code
 
-**Claude Code** (`~/.claude.json`):
+`~/.claude.json`:
 ```json
 {
   "mcpServers": {
     "memorix": {
-      "command": "memorix",
-      "args": ["serve"]
+      "command": "npx",
+      "args": ["-y", "memorix@latest", "serve"]
     }
   }
 }
 ```
 
-**Codex** (`~/.codex/config.toml`):
+### Codex
+
+`~/.codex/config.toml`:
 ```toml
 [mcp_servers.memorix]
-command = "memorix"
-args = ["serve"]
+command = "npx"
+args = ["-y", "memorix@latest", "serve"]
 ```
 
-**VS Code Copilot** (VS Code `settings.json` or `.vscode/mcp.json`):
+### VS Code Copilot
+
+`.vscode/mcp.json` or VS Code `settings.json`:
 ```json
 {
   "mcp": {
     "servers": {
       "memorix": {
-        "command": "memorix",
-        "args": ["serve"]
+        "command": "npx",
+        "args": ["-y", "memorix@latest", "serve"]
       }
     }
   }
 }
 ```
 
-### Available MCP Tools
+### Antigravity
+
+`~/.gemini/antigravity/settings/mcp_config.json`:
+```json
+{
+  "mcpServers": {
+    "memorix": {
+      "command": "npx",
+      "args": ["-y", "memorix@latest", "serve"]
+    }
+  }
+}
+```
+
+---
+
+## 🛠 Available MCP Tools
 
-#### Memorix Extensions (Progressive Disclosure)
+### Memorix Extensions
 
-| Tool | Layer | Description | Tokens |
-|------|-------|-------------|--------|
-| `memorix_store` | Write | Store observation with auto-enrichment | — |
-| `memorix_search` | L1 | Compact index search (hybrid if fastembed) | ~50-100/result |
-| `memorix_timeline` | L2 | Chronological context | ~200/group |
-| `memorix_detail` | L3 | Full observation details | ~500-1000/result |
-| `memorix_retention` | Analytics | Memory decay & retention status | — |
-| `memorix_rules_sync` | Rules | Scan, dedup, convert rules across agents | — |
-| `memorix_workspace_sync` | Workspace | Scan/migrate MCP configs, workflows, and skills across agents | — |
+| Tool | Purpose | Token Cost |
+|------|---------|------------|
+| `memorix_store` | Store observation with auto-enrichment | — |
+| `memorix_search` | L1: Compact index search | ~50-100/result |
+| `memorix_timeline` | L2: Chronological context | ~100-200/group |
+| `memorix_detail` | L3: Full observation details | ~500-1000/result |
+| `memorix_retention` | Memory decay & retention dashboard | — |
+| `memorix_rules_sync` | Scan/deduplicate/generate rules across agents | — |
+| `memorix_workspace_sync` | Migrate MCP configs, workflows, skills | — |
 
-#### MCP Official Compatible
+### MCP Official Compatible (Drop-in Replacement)
 
-| Tool | Description |
-|------|-------------|
+| Tool | Purpose |
+|------|---------|
 | `create_entities` | Create knowledge graph entities |
 | `create_relations` | Create relations between entities |
 | `add_observations` | Add observations to entities |
@@ -176,101 +217,165 @@ args = ["serve"]
 | `open_nodes` | Get entities by name |
 | `read_graph` | Read entire graph |
 
-## Architecture
+---
+
+## 🧩 How It Works
+
+### Data Flow
 
 ```
-┌─────────────────────────────────────────────┐
-│                 MCP Clients                  │
-│ Windsurf│Cursor│Claude Code│Codex│Copilot │
-└──────────────────┬──────────────────────────┘
-                   │ stdio
-┌──────────────────▼──────────────────────────┐
-│              Memorix MCP Server              │
-│                                              │
-│  ┌────────────┐  ┌─────────────────────┐    │
-│  │ Knowledge  │  │  Compact Engine     │    │
-│  │ Graph Mgr  │  │  (3-layer search)   │    │
-│  └─────┬──────┘  └──────────┬──────────┘    │
-│        │                    │                │
-│  ┌─────▼────────────────────▼──────────┐    │
-│  │           Orama Store               │    │
-│  │    (full-text + vector search)      │    │
-│  └─────────────────┬──────────────────┘    │
-│                    │                        │
-│  ┌─────────────────▼──────────────────┐    │
-│  │         Persistence Layer           │    │
-│  │   (JSONL + JSON per project)        │    │
-│  └─────────────────────────────────────┘    │
-│                                              │
-│  ┌────────────────────────────────────┐     │
-│  │      Rules & Skills Syncer        │     │
-│  │  Cursor│Claude Code│Codex│Windsurf│Copilot│ │
-│  │  rules: scan→dedup→conflict→gen   │     │
-│  │  skills: scan→copy (no convert)   │     │
-│  └────────────────────────────────────┘     │
-│                                              │
-│  ┌────────────────────────────────────┐     │
-│  │       Auto-Memory Hooks           │     │
-│  │  normalize→detect→filter→store    │     │
-│  │  + agent rules (context cont.)    │     │
-│  └────────────────────────────────────┘     │
-└──────────────────────────────────────────────┘
+Agent ──memorix_store──▶ Entity Extractor ──▶ Auto-Relations ──▶ Knowledge Graph
+                         │                                        │
+                         ▼                                        │
+                     Orama Index ◀───────── Persistence Layer ◀───┘
+                     (BM25 + Vector)        (~/.memorix/data/<project>/)
+                         │
+Agent ◀──memorix_search──┘  L1: Compact Index (~50-100 tokens)
+Agent ◀──memorix_timeline─  L2: Timeline Context
+Agent ◀──memorix_detail───  L3: Full Details (~500-1000 tokens)
 ```
 
-## Tech Stack
+### Progressive Disclosure Example
 
-| Component | Library | Source |
-|-----------|---------|--------|
-| MCP Server | `@modelcontextprotocol/sdk` | Official SDK |
-| Search | `@orama/orama` | Full-text + Vector + Hybrid |
-| Embeddings | `fastembed` (optional) | Local ONNX, zero API calls |
-| Token counting | `gpt-tokenizer` | — |
-| Data model | Entity-Relation-Observation | MCP Official Memory Server |
-| Compact strategy | 3-layer Progressive Disclosure | claude-mem |
-| Memory decay | Exponential decay + retention | mcp-memory-service + MemCP |
-| Entity extraction | Regex patterns | MemCP |
-| Rule parsing | `gray-matter` | — |
-| Build | `tsup` | — |
-| Test | `vitest` | 219 tests |
+```
+🔍 Agent calls memorix_search("auth bug")
+
+📋 L1 Response (compact — agent scans IDs):
+| ID  | Time    | T  | Title                    | Tokens |
+|-----|---------|-----|--------------------------|--------|
+| #42 | 2:14 PM | 🟡 | Fixed JWT refresh timeout | ~155   |
+| #38 | 1:30 PM | 🔵 | How JWT refresh works     | ~220   |
+
+🔎 Agent calls memorix_detail([42])
+
+📄 L3 Response (full content):
+# Observation #42 — Fixed JWT refresh timeout
+Type: 🟡 problem-solution | Entity: auth-module
+Narrative: The JWT refresh token was timing out after 15 minutes
+because the expiry was hardcoded. Fixed by reading from env...
+Facts: ["Default timeout: 60s", "Fix: use REFRESH_TTL env var"]
+Files: ["src/auth/jwt.ts", "src/config.ts"]
+```
+
+### Architecture
+
+```
+┌──────────────────────────────────────────────────────────────┐
+│                    AI Coding Agents                           │
+│  Windsurf │ Cursor │ Claude Code │ Codex │ Copilot │ Antigravity
+└────────────────────────┬─────────────────────────────────────┘
+                         │ MCP Protocol (stdio)
+┌────────────────────────▼─────────────────────────────────────┐
+│                 Memorix MCP Server (16 tools)                │
+│                                                              │
+│  ┌─────────────┐  ┌──────────────┐  ┌──────────────────┐   │
+│  │   Memory     │  │   Compact    │  │  Workspace Sync  │   │
+│  │   Layer      │  │   Engine     │  │  (6 adapters)    │   │
+│  │             │  │  (3-layer)   │  │                  │   │
+│  │ • Graph     │  │              │  │ • MCP Configs    │   │
+│  │ • Retention │  │              │  │ • Rules          │   │
+│  │ • Entities  │  │              │  │ • Skills         │   │
+│  │ • Relations │  │              │  │ • Workflows      │   │
+│  └──────┬──────┘  └──────┬───────┘  └──────────────────┘   │
+│         │                │                                   │
+│  ┌──────▼────────────────▼───────────────────────────────┐  │
+│  │  Orama Store (BM25 + Vector) │ Persistence (JSONL)    │  │
+│  └───────────────────────────────────────────────────────┘  │
+│                                                              │
+│  ┌───────────────────────────────────────────────────────┐  │
+│  │  Hooks System: Normalizer → Pattern Detector → Store  │  │
+│  │  (Auto-captures decisions, bugs, gotchas from agents) │  │
+│  └───────────────────────────────────────────────────────┘  │
+└──────────────────────────────────────────────────────────────┘
+```
 
-## Optional: Enable Vector Search
+---
+
+## 🔮 Optional: Vector Search
 
 Install `fastembed` for hybrid (BM25 + semantic) search:
 
 ```bash
-npm install fastembed
+npm install -g fastembed
 ```
 
-Without it, Memorix uses BM25 full-text search (already very effective for code memories). With it, queries like "authentication" will also match observations containing "login flow".
+- **Without it** — BM25 full-text search (already very effective for code)
+- **With it** — Queries like "authentication" also match "login flow" via semantic similarity
+- Local ONNX inference, zero API calls, zero privacy risk
+
+---
 
-## Development
+## 💾 Data Storage
+
+All data is stored locally per project:
+
+```
+~/.memorix/data/<projectId>/
+├── observations.json      # Structured observations
+├── id-counter.txt         # Next observation ID
+├── entities.jsonl         # Knowledge graph nodes (MCP compatible)
+└── relations.jsonl        # Knowledge graph edges (MCP compatible)
+```
+
+- `projectId` is auto-detected from Git remote URL (e.g., `user/repo`)
+- Data is shared across all agents (same directory)
+- No cloud, no API keys, no external services
+
+---
+
+## 🧑‍💻 Development
 
 ```bash
-# Install dependencies
+git clone https://github.com/AVIDS2/memorix.git
+cd memorix
 npm install
 
-# Build
-npm run build
-
-# Run tests (219 tests)
-npm test
+npm run dev          # tsup watch mode
+npm test             # vitest (274 tests)
+npm run lint         # TypeScript type check
+npm run build        # Production build
+```
 
-# Type check
-npm run lint
+### Project Structure
 
-# Watch mode
-npm run dev
 ```
+src/
+├── server.ts              # MCP Server entry (16 tools)
+├── types.ts               # All type definitions
+├── memory/                # Graph, observations, retention, entity extraction
+├── store/                 # Orama search engine + disk persistence
+├── compact/               # 3-layer Progressive Disclosure engine
+├── embedding/             # Optional fastembed vector provider
+├── hooks/                 # Auto-memory hooks (normalizer + pattern detector)
+├── workspace/             # Cross-agent MCP/workflow/skills sync
+├── rules/                 # Cross-agent rules sync (6 adapters)
+├── project/               # Git-based project detection
+└── cli/                   # CLI commands (serve, hook, sync, status)
+```
+
+> 📚 Full documentation available in [`docs/`](./docs/) — architecture, modules, API reference, design decisions, and more.
+
+---
 
-## Acknowledgements
+## 🙏 Acknowledgements
 
 Memorix stands on the shoulders of these excellent projects:
 
 - [mcp-memory-service](https://github.com/doobidoo/mcp-memory-service) — Hybrid search, exponential decay, access tracking
-- [MemCP](https://github.com/maydali28/memcp) — MAGMA 4-graph, entity extraction, retention lifecycle, token budget
-- [claude-mem](https://github.com/anthropics/claude-code) — 3-layer Progressive Disclosure, lifecycle hooks
+- [MemCP](https://github.com/maydali28/memcp) — MAGMA 4-graph, entity extraction, retention lifecycle
+- [claude-mem](https://github.com/anthropics/claude-code) — 3-layer Progressive Disclosure
 - [Mem0](https://github.com/mem0ai/mem0) — Memory layer architecture patterns
 
-## License
+---
+
+## 📄 License
 
 Apache 2.0 — see [LICENSE](LICENSE)
+
+---
+
+<p align="center">
+  <strong>Made with ❤️ by <a href="https://github.com/AVIDS2">AVIDS2</a></strong>
+  <br>
+  <sub>If Memorix helps your workflow, consider giving it a ⭐ on GitHub!</sub>
+</p>