linksee-memory 0.2.0 → 0.4.0

package/README.md

@@ -1,15 +1,25 @@
 # linksee-memory
 
-> Local-first agent memory MCP. A cross-agent brain for Claude Code, Cursor, and ChatGPT Desktop — with a token-saving file diff cache that nobody else does.
+> Local-first agent memory MCP. A cross-agent brain for **Claude Code, Cursor, OpenAI Codex, and Gemini CLI** — with a token-saving file diff cache that nobody else does. One SQLite file, all your LLMs read the same memory.
 >
-> **v0.2.0** makes the package English-first for global launch: the bundled auto-invocation skill is now bilingual (EN + JP), session-extractor patterns cover common English keywords (`let's go`, `pivot`, `doesn't work`, `same error again`, etc.), and the install CLI shows test examples in both languages. No API changes. See [CHANGELOG](#changelog).
+> **v0.3.0** ships the **Five Blocks**: Tools + Resources + Prompts + Sampling + Roots, plus the newer **Elicitation** primitive. Most public MCP servers expose only Tools; v0.3.0 moves linksee-memory into the differentiated tier. Backward compatible — all 8 v0.2.x tools keep their signatures. See [CHANGELOG.md](./CHANGELOG.md).
 
 [![npm](https://img.shields.io/npm/v/linksee-memory.svg)](https://www.npmjs.com/package/linksee-memory)
 [![license](https://img.shields.io/npm/l/linksee-memory.svg)](./LICENSE)
 [![mcp-registry](https://img.shields.io/badge/MCP-Official_Registry-6366f1)](https://registry.modelcontextprotocol.io/)
 [![glama-score](https://glama.ai/mcp/servers/michielinksee/linksee-memory/badges/score.svg)](https://glama.ai/mcp/servers/michielinksee/linksee-memory)
 
-🌐 **Landing page**: [linksee-site.vercel.app](https://linksee-site.vercel.app) (includes non-developer onboarding for Claude Desktop / Cursor / Claude Code)
+🌐 **Landing page**: [linksee-site.vercel.app](https://linksee-site.vercel.app) (includes non-developer onboarding for Claude Desktop / Cursor / Claude Code / OpenAI Codex / Gemini CLI)
+
+## 📣 As featured on
+
+- **Zenn**: [あなたの Claude Code、 実は前回のセッションを完全に忘れている](https://zenn.dev/kanseilink/articles/linksee-memory-claude-code-recall-20260508) — 73 ♡ on Zenn, **165+ users on Hatena Bookmark**, picked up by tech blogs + YouTube shorts (May 2026)
+- **Zenn**: [あなたの MCP server、 実は Tools しか使ってない (5 blocks 全実装 / v0.3.0)](https://zenn.dev/kanseilink/articles/linksee-memory-mcp-five-blocks-20260507) — the 1% of MCP servers that implement all 5 blocks
+- **Zenn**: [あなたの Claude memory、 実は Claude にしか残らない (5 LLM 横断する方法)](https://zenn.dev/kanseilink/articles/linksee-memory-claude-cross-llm-20260511) — cross-LLM memory pattern (May 12, 2026)
+- **Zenn**: [Glama listing で 3 週間止まった話 (5 つの罠と解決策)](https://zenn.dev/michielinksee/articles/linksee-memory-mcp-publish-glama-traps-20260506) — npm + Glama deployment retrospective
+
+> 「Cordex/Cursor/Code/Gemini 全部につなげられるから、 横断的にできてる MCP ってところがこれのすごいところ」
+> — [Hatena Bookmark, May 2026](https://b.hatena.ne.jp/entry/s/zenn.dev/kanseilink/articles/linksee-memory-claude-code-recall-20260508) (165+ users)
 
 ---
 
@@ -88,7 +98,7 @@ It is a Model Context Protocol (MCP) server that gives any AI agent four superpo
 ## Three pillars
 
 1. **Token savings** via `read_smart` — sha256 + AST/heading/indent chunking. Re-reads return only diffs. **Measured 86% saved on a typical TS file edit, 99% saved on unchanged re-reads.**
-2. **Cross-agent portability** — single SQLite file at `~/.linksee-memory/memory.db`. Same brain for Claude Code, Cursor, ChatGPT Desktop.
+2. **Cross-agent portability** — single SQLite file at `~/.linksee-memory/memory.db`. Same brain for Claude Code, Cursor, OpenAI Codex, Gemini CLI. (ChatGPT app needs Remote MCP — on roadmap for v0.4.)
 3. **WHY-first structured memory** — six explicit layers (`goal` / `context` / `emotion` / `implementation` / `caveat` / `learning`). Solves "flat fact memory is useless without goals".
 
 ## Install
@@ -147,18 +157,29 @@ Add to `~/.claude/settings.json` to record every Claude Code session to your loc
 
 Each turn end takes ~100 ms. Failures are silent (Claude Code never blocks). Logs at `~/.linksee-memory/hook.log`.
 
+## v0.3.0 — Five Blocks at a glance
+
+| MCP Block | Surface |
+|---|---|
+| **Tools** | 8 tools (unchanged signatures since v0.2). |
+| **Resources** | 4 static URIs (`memory://stats`, `memory://hot`, `memory://recent`, `memory://caveats`) + 3 templates (`memory://entity/{name}`, `memory://layer/{layer}`, `memory://memory/{id}`). Browseable via `@-mention` in clients that support it. |
+| **Prompts** | 5 reusable templates: `summarize-session`, `extract-caveats`, `weekly-consolidation`, `recall-and-write`, `entity-handoff`. |
+| **Sampling** *(client opt-in)* | `consolidate{use_llm:true}` asks the client LLM to rewrite consolidated cluster summaries into prose. Falls back to the heuristic when the client declines. |
+| **Roots** *(client opt-in)* | `recall_file{scope_to_roots:true}` filters path matches to files inside any client-provided working root. |
+| **Elicitation** *(client opt-in, newer primitive)* | `forget{interactive:true, memory_id:N}` asks the user to confirm via the client UI before deleting. |
+
 ## Tools
 
 | Tool | Purpose |
 |---|---|
 | `remember` | Store memory in 1 of 6 layers for an entity. Rejects pasted assistant output / CI logs unless `force=true`. Set `importance=1.0` to pin (survives auto-forget). |
 | `recall` | FTS5 + heat × momentum × importance composite ranking with `match_reasons` explaining WHY each row matched. Supports pagination (`offset`/`has_more`), `band` filter, layer aliases (`decisions`/`warnings`/`how`/...), and `mark_accessed=false` for passive previews. |
-| `recall_file` | Complete edit history of a file across all sessions, with per-edit user-intent context. |
+| `recall_file` | Complete edit history of a file across all sessions, with per-edit user-intent context. **v0.3.0** `scope_to_roots` flag filters by client roots. |
 | `update_memory` | **v0.1.0** Atomic edit of an existing memory. Preserves `memory_id` (session_file_edits links stay intact). Prefer over forget+remember. |
 | `list_entities` | **v0.1.0** List what the memory knows about — cheapest "what do I know?" primitive. Filter by `kind`/`min_memories`; returns layer breakdown per entity. |
 | `read_smart` | Diff-only file read. Returns full content on first read, ~50 tokens on unchanged re-reads, only changed chunks on real edits. |
-| `forget` | Explicit delete OR auto-sweep based on `forgettingRisk`. Pinned (`importance>=1.0`) and caveat-layer memories are always preserved. |
-| `consolidate` | Sleep-mode compression: cluster cold low-importance memories → protected learning-layer summary. Supports `dry_run` preview. |
+| `forget` | Explicit delete OR auto-sweep based on `forgettingRisk`. Pinned (`importance>=1.0`) and caveat-layer memories are always preserved. **v0.3.0** `interactive` flag asks the user via Elicitation before deleting a specific memory_id. |
+| `consolidate` | Sleep-mode compression: cluster cold low-importance memories → protected learning-layer summary. Supports `dry_run` preview. **v0.3.0** `use_llm` flag asks the client LLM (Sampling) to rewrite cluster summaries into prose. |
 
 ### CLI utilities
 
@@ -215,9 +236,12 @@ The conversation↔file linkage is the key. Every file edit captured by the Stop
 - ✅ Core 6 MCP tools (`remember` / `recall` / `recall_file` / `forget` / `consolidate` / `read_smart`)
 - ✅ Stop-hook auto-capture for Claude Code
 - ✅ JP/EN trigram FTS5
+- ✅ Five Blocks (v0.3.0): Tools + Resources + Prompts + Sampling + Roots + Elicitation
+- ✅ Cursor + OpenAI Codex + Gemini CLI adapters (stdio MCP, same `npx -y linksee-memory`)
 - 🚧 `PreToolUse` hook to auto-intercept `Read` (zero-config token savings)
-- 🚧 Cursor + ChatGPT Desktop adapters
-- 🔮 Vector search via `sqlite-vec` once an embedding backend is chosen (Ollama / API / etc.)
+- 🔮 ChatGPT app (web/mobile) support via `linksee-memory-remote` (Remote MCP over HTTPS, v0.4)
+- 🔮 Vector search via `sqlite-vec` (already in deps, embedding backend pending)
+- 🔮 Cross-device cloud sync (Pro tier, summer 2026)
 - 🔮 Optional anonymized telemetry → MCP-quality intelligence layer
 
 ## Comparison with Claude Code auto-memory
@@ -365,8 +389,8 @@ Three axes:
 <details>
 <summary><strong>Why not just use Claude's built-in auto-memory?</strong></summary>
 
-Claude Code's auto-memory is Claude-only (doesn't help if you switch to Cursor or ChatGPT Desktop) and stores flat markdown with no structure. linksee-memory is the same local-first principle but:
-- Works across Claude Code, Cursor, ChatGPT Desktop (shared SQLite)
+Claude Code's auto-memory is Claude-only (doesn't help if you switch to Cursor, OpenAI Codex, or Gemini CLI) and stores flat markdown with no structure. linksee-memory is the same local-first principle but:
+- Works across Claude Code, Cursor, OpenAI Codex, Gemini CLI (shared SQLite)
 - Structured 6-layer format makes recall explainable
 - Provides explicit forget/consolidate primitives rather than the agent guessing
 </details>
@@ -404,8 +428,10 @@ In practice a solo developer hits ~100MB after 6 months of heavy use. A year-old
 Yes — any MCP-compatible client works:
 - **Claude Code**: `claude mcp add -s user linksee -- npx -y linksee-memory`
 - **Claude Desktop**: add to `claude_desktop_config.json` (see [onboarding on the LP](https://linksee-site.vercel.app))
-- **Cursor**: add to MCP settings in Cursor
-- **ChatGPT Desktop**: same pattern once MCP support ships
+- **Cursor**: add to MCP settings in Cursor → Settings → Features → Model Context Protocol
+- **OpenAI Codex**: `codex mcp add linksee -- npx -y linksee-memory` (or `~/.codex/config.toml` with `[mcp_servers.linksee]` block)
+- **Gemini CLI**: add to `~/.gemini/settings.json` mcpServers section
+- **ChatGPT (web/mobile app)**: stdio MCP not supported by the consumer app — requires Remote MCP server over HTTPS. `linksee-memory-remote` planned for v0.4.
 - **Custom agent**: the MCP stdio protocol is documented at modelcontextprotocol.io
 </details>
 

package/dist/bin/import-sessions.js

@@ -13,6 +13,7 @@ import { homedir } from 'node:os';
 import { openDb, runMigrations } from '../db/migrate.js';
 import { parseSessionFile, detectProjectName } from '../lib/session-parser.js';
 import { extractSession } from '../lib/session-extractor.js';
+import { normalizeEntityName } from '../lib/normalize.js';
 const CLAUDE_PROJECTS = join(homedir(), '.claude', 'projects');
 function usage() {
     console.log(`Usage:
@@ -90,12 +91,15 @@ async function main() {
         // different sessions/cwds collapses to one entity)
         let projectEntityId;
         const canonicalKey = `project:${projectName.toLowerCase()}`;
-        const existing = db.prepare('SELECT id FROM entities WHERE canonical_key = ? OR (kind = ? AND LOWER(name) = LOWER(?))').get(canonicalKey, 'project', projectName);
+        const normalized = normalizeEntityName(projectName);
+        const existing = db.prepare('SELECT id FROM entities WHERE canonical_key = ? OR (kind = ? AND normalized_name = ?) OR (kind = ? AND LOWER(name) = LOWER(?))').get(canonicalKey, 'project', normalized, 'project', projectName);
         if (existing) {
             projectEntityId = existing.id;
+            // Backfill normalized_name if missing
+            db.prepare('UPDATE entities SET normalized_name = ? WHERE id = ? AND normalized_name IS NULL').run(normalized, projectEntityId);
         }
         else {
-            const ins = db.prepare('INSERT INTO entities (kind, name, canonical_key) VALUES (?, ?, ?)').run('project', projectName, canonicalKey);
+            const ins = db.prepare('INSERT INTO entities (kind, name, normalized_name, canonical_key) VALUES (?, ?, ?, ?)').run('project', projectName, normalized, canonicalKey);
             projectEntityId = Number(ins.lastInsertRowid);
         }
         const insMem = db.prepare('INSERT INTO memories (entity_id, layer, content, importance, source) VALUES (?, ?, ?, ?, ?)');
@@ -207,12 +211,14 @@ async function main() {
             // Resolve entity per-SESSION (not per-project-dir) since each session may
             // belong to a different project based on its file ops.
             const canonicalKey = `project:${projectName.toLowerCase()}`;
-            const existing = db.prepare('SELECT id FROM entities WHERE canonical_key = ? OR (kind = ? AND LOWER(name) = LOWER(?))').get(canonicalKey, 'project', projectName);
+            const normalized = normalizeEntityName(projectName);
+            const existing = db.prepare('SELECT id FROM entities WHERE canonical_key = ? OR (kind = ? AND normalized_name = ?) OR (kind = ? AND LOWER(name) = LOWER(?))').get(canonicalKey, 'project', normalized, 'project', projectName);
             if (existing) {
                 projectEntityId = existing.id;
+                db.prepare('UPDATE entities SET normalized_name = ? WHERE id = ? AND normalized_name IS NULL').run(normalized, projectEntityId);
             }
             else {
-                const ins = db.prepare('INSERT INTO entities (kind, name, canonical_key) VALUES (?, ?, ?)').run('project', projectName, canonicalKey);
+                const ins = db.prepare('INSERT INTO entities (kind, name, normalized_name, canonical_key) VALUES (?, ?, ?, ?)').run('project', projectName, normalized, canonicalKey);
                 projectEntityId = Number(ins.lastInsertRowid);
             }
             // Idempotent: wipe any prior data for THIS session before re-inserting (Phase B)

package/dist/db/migrate.js

@@ -4,6 +4,7 @@ import { mkdirSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { homedir } from 'node:os';
 import { fileURLToPath } from 'node:url';
+import { normalizeEntityName } from '../lib/normalize.js';
 const DEFAULT_DB_DIR = process.env.LINKSEE_MEMORY_DIR ?? join(homedir(), '.linksee-memory');
 const DB_PATH = join(DEFAULT_DB_DIR, 'memory.db');
 export function getDbPath() {
@@ -39,6 +40,14 @@ export function runMigrations(db) {
       DROP TABLE IF EXISTS memories_fts;
     `);
     }
+    // v4 → v5: add normalized_name column BEFORE schema.sql runs,
+    // so the CREATE INDEX IF NOT EXISTS on (kind, normalized_name) succeeds.
+    if (currentVersion > 0 && currentVersion < 5) {
+        const cols = db.prepare("PRAGMA table_info(entities)").all();
+        if (!cols.some(c => c.name === 'normalized_name')) {
+            db.exec('ALTER TABLE entities ADD COLUMN normalized_name TEXT');
+        }
+    }
     db.exec(sql);
     if (currentVersion > 0 && currentVersion < 4) {
         db.exec(`INSERT INTO memories_fts(rowid, content) SELECT id, content FROM memories;`);
@@ -57,6 +66,95 @@ export function runMigrations(db) {
     if (hasMemories?.name) {
         db.prepare(`UPDATE memories SET protected = 1 WHERE importance >= 0.9 AND protected = 0`).run();
     }
+    // v4 → v5: entity name normalization for dedup prevention.
+    // Adds normalized_name column + backfills from existing entity names.
+    if (currentVersion > 0 && currentVersion < 5) {
+        migrateV5EntityNormalization(db);
+    }
+}
+/**
+ * v5 migration: add normalized_name column and backfill + merge duplicates.
+ */
+function migrateV5EntityNormalization(db) {
+    // Column + index already added before db.exec(sql) above.
+    // Now backfill normalized_name for all entities.
+    const entities = db.prepare('SELECT id, name FROM entities').all();
+    const updateStmt = db.prepare('UPDATE entities SET normalized_name = ? WHERE id = ?');
+    db.transaction(() => {
+        for (const e of entities) {
+            updateStmt.run(normalizeEntityName(e.name), e.id);
+        }
+    })();
+    // 4. Auto-merge duplicate entities (same kind + normalized_name)
+    const dupes = db.prepare(`
+    SELECT kind, normalized_name, GROUP_CONCAT(id) as ids
+    FROM entities
+    WHERE normalized_name IS NOT NULL
+    GROUP BY kind, normalized_name
+    HAVING COUNT(*) > 1
+  `).all();
+    if (dupes.length > 0) {
+        console.log(`[linksee-memory] v5 migration: merging ${dupes.length} duplicate entity clusters`);
+        db.transaction(() => {
+            for (const dupe of dupes) {
+                const ids = dupe.ids.split(',').map(Number);
+                mergeEntityCluster(db, ids);
+            }
+        })();
+    }
+}
+/**
+ * Merge a cluster of duplicate entity IDs into one canonical entity.
+ * Picks the entity with the most memories (ties broken by canonical_key presence).
+ * Reassigns all memories, events, edges, consolidations to the kept entity.
+ */
+function mergeEntityCluster(db, ids) {
+    if (ids.length < 2)
+        return;
+    // Score each entity: prefer most memories, then has canonical_key, then lowest id
+    const rows = db.prepare(`
+    SELECT e.id, e.name, e.canonical_key, COUNT(m.id) as mem_count
+    FROM entities e LEFT JOIN memories m ON m.entity_id = e.id
+    WHERE e.id IN (${ids.map(() => '?').join(',')})
+    GROUP BY e.id
+    ORDER BY mem_count DESC, (e.canonical_key IS NOT NULL) DESC, e.id ASC
+  `).all(...ids);
+    const keep = rows[0];
+    const mergeIds = rows.slice(1).map(r => r.id);
+    console.log(`  merge: keeping "${keep.name}" (id=${keep.id}, ${keep.mem_count} memories), absorbing ids=[${mergeIds.join(',')}]`);
+    // Inherit canonical_key if the kept entity lacks one
+    // Clear donor's key first to avoid UNIQUE constraint violation
+    if (!keep.canonical_key) {
+        const donor = rows.find(r => r.id !== keep.id && r.canonical_key);
+        if (donor) {
+            db.prepare('UPDATE entities SET canonical_key = NULL WHERE id = ?').run(donor.id);
+            db.prepare('UPDATE entities SET canonical_key = ? WHERE id = ?').run(donor.canonical_key, keep.id);
+        }
+    }
+    for (const mid of mergeIds) {
+        // Reassign memories
+        db.prepare('UPDATE memories SET entity_id = ? WHERE entity_id = ?').run(keep.id, mid);
+        // Reassign events
+        db.prepare('UPDATE events SET entity_id = ? WHERE entity_id = ?').run(keep.id, mid);
+        // Reassign edges (both directions)
+        // Handle UNIQUE constraint: delete duplicates first
+        db.prepare(`
+      DELETE FROM edges WHERE from_id = ? AND EXISTS (
+        SELECT 1 FROM edges e2 WHERE e2.from_id = ? AND e2.to_id = edges.to_id AND e2.relation = edges.relation
+      )
+    `).run(mid, keep.id);
+        db.prepare('UPDATE edges SET from_id = ? WHERE from_id = ?').run(keep.id, mid);
+        db.prepare(`
+      DELETE FROM edges WHERE to_id = ? AND EXISTS (
+        SELECT 1 FROM edges e2 WHERE e2.to_id = ? AND e2.from_id = edges.from_id AND e2.relation = edges.relation
+      )
+    `).run(mid, keep.id);
+        db.prepare('UPDATE edges SET to_id = ? WHERE to_id = ?').run(keep.id, mid);
+        // Reassign consolidations
+        db.prepare('UPDATE consolidations SET entity_id = ? WHERE entity_id = ?').run(keep.id, mid);
+        // Delete the duplicate entity
+        db.prepare('DELETE FROM entities WHERE id = ?').run(mid);
+    }
 }
 // CLI entrypoint
 if (import.meta.url === `file://${process.argv[1]}` || process.argv[1]?.endsWith('migrate.ts') || process.argv[1]?.endsWith('migrate.js')) {

package/dist/db/schema.sql

@@ -10,6 +10,7 @@ CREATE TABLE IF NOT EXISTS entities (
   id              INTEGER PRIMARY KEY AUTOINCREMENT,
   kind            TEXT NOT NULL CHECK (kind IN ('person', 'company', 'project', 'concept', 'file', 'other')),
   name            TEXT NOT NULL,
+  normalized_name TEXT,                            -- lowercased, separator-normalized for dedup matching
   canonical_key   TEXT UNIQUE,
   attributes      TEXT,
   momentum_score  REAL NOT NULL DEFAULT 0.0,      -- 0-10 cached; refreshed on event insert
@@ -18,8 +19,9 @@ CREATE TABLE IF NOT EXISTS entities (
   updated_at      INTEGER NOT NULL DEFAULT (unixepoch())
 );
 
-CREATE INDEX IF NOT EXISTS idx_entities_kind ON entities(kind);
-CREATE INDEX IF NOT EXISTS idx_entities_key  ON entities(canonical_key);
+CREATE INDEX IF NOT EXISTS idx_entities_kind       ON entities(kind);
+CREATE INDEX IF NOT EXISTS idx_entities_key        ON entities(canonical_key);
+CREATE INDEX IF NOT EXISTS idx_entities_normalized ON entities(kind, normalized_name);
 
 -- ============================================================
 -- Layer 3: Meanings — 6-layer structured memory per entity
@@ -194,6 +196,6 @@ CREATE TABLE IF NOT EXISTS meta (
   value         TEXT NOT NULL
 );
 
-INSERT OR IGNORE INTO meta (key, value) VALUES ('schema_version', '4');
+INSERT OR IGNORE INTO meta (key, value) VALUES ('schema_version', '5');
 INSERT OR IGNORE INTO meta (key, value) VALUES ('created_at', CAST(unixepoch() AS TEXT));
-UPDATE meta SET value = '4' WHERE key = 'schema_version' AND value IN ('1', '2', '3');
+UPDATE meta SET value = '5' WHERE key = 'schema_version' AND value IN ('1', '2', '3', '4');

package/dist/lib/normalize.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Entity name normalization for deduplication.
+ *
+ * Problem: agents call the same project by different names:
+ *   "CockpitMCP" / "Cockpit MCP" / "cockpit-mcp" / "Cockpit_MCP"
+ *   "Linksee Memory" / "LinkseeMemory" / "linksee-memory"
+ *   "Sake_Navi" / "Sake Navi"
+ *
+ * This module provides a single normalizeEntityName() that collapses
+ * all these variants to one canonical form for matching.
+ */
+/**
+ * Normalize an entity name for dedup matching.
+ *
+ * Rules applied (in order):
+ *   1. CamelCase split:  "CockpitMCP"    → "Cockpit MCP"
+ *   2. Separator → space: "linksee-memory" → "linksee memory"
+ *   3. Lowercase:          "Linksee Memory" → "linksee memory"
+ *   4. Collapse whitespace
+ *   5. Trim
+ *
+ * The result is used for equality matching (WHERE normalized_name = ?),
+ * NOT stored as the display name — the original name is preserved.
+ */
+export declare function normalizeEntityName(name: string): string;

package/dist/lib/normalize.js

@@ -0,0 +1,43 @@
+/**
+ * Entity name normalization for deduplication.
+ *
+ * Problem: agents call the same project by different names:
+ *   "CockpitMCP" / "Cockpit MCP" / "cockpit-mcp" / "Cockpit_MCP"
+ *   "Linksee Memory" / "LinkseeMemory" / "linksee-memory"
+ *   "Sake_Navi" / "Sake Navi"
+ *
+ * This module provides a single normalizeEntityName() that collapses
+ * all these variants to one canonical form for matching.
+ */
+/**
+ * Normalize an entity name for dedup matching.
+ *
+ * Rules applied (in order):
+ *   1. CamelCase split:  "CockpitMCP"    → "Cockpit MCP"
+ *   2. Separator → space: "linksee-memory" → "linksee memory"
+ *   3. Lowercase:          "Linksee Memory" → "linksee memory"
+ *   4. Collapse whitespace
+ *   5. Trim
+ *
+ * The result is used for equality matching (WHERE normalized_name = ?),
+ * NOT stored as the display name — the original name is preserved.
+ */
+export function normalizeEntityName(name) {
+    return name
+        // CamelCase boundaries: insert space between lowercase→uppercase
+        //   "CockpitMCP" → "Cockpit MCP"
+        //   "LinkseeMemory" → "Linksee Memory"
+        .replace(/([a-z])([A-Z])/g, '$1 $2')
+        // Uppercase run followed by uppercase+lowercase:
+        //   "MCPServer" → "MCP Server"
+        //   "KanseiLINK" → "Kansei LINK"
+        .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2')
+        // All separators → space
+        .replace(/[-_]/g, ' ')
+        // Lowercase everything
+        .toLowerCase()
+        // Collapse multiple spaces
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+//# sourceMappingURL=normalize.js.map