@pi-unipi/memory 2.0.12 → 2.1.0

package/README.md

@@ -1,8 +1,10 @@
 # @pi-unipi/memory
 
-Persistent memory that survives across sessions. Stores facts, preferences, and decisions in SQLite with vector search, so the agent remembers what you told it last week.
+Persistent memory that survives across sessions. Stores facts, preferences, and decisions with semantic vector search, so the agent remembers what you told it last week.
 
-Two storage tiers: SQLite + sqlite-vec for vector similarity search, markdown files for human-readable memories you can edit by hand. Project-scoped memories stay separate per codebase, global memories are accessible everywhere.
+**Primary backend: [MemPalace](https://github.com/mempalace/mempalace)** — auto-installed via `uv` on first load, with one-way auto-migration of any existing legacy memories. If MemPalace or `uv` is unavailable, the package transparently falls back to the bundled SQLite + sqlite-vec store, so memory never hard-fails.
+
+Two storage tiers: MemPalace (or SQLite) for vector similarity search, markdown files for a durable human-readable copy you can edit by hand. Project-scoped memories stay separate per codebase, global memories are accessible everywhere.
 
 ## Commands
 
@@ -72,19 +74,61 @@ Examples:
 Memory has no configuration file. Storage paths are fixed:
 
 ```
-~/.unipi/memory/
+~/.unipi/memory/                 # UniPi memory root (legacy + markdown tier)
+├── .mempalace-install           # Cached MemPalace venv detection
+├── .mempalace-migrated          # One-way migration completion flag
 ├── global/
-│   ├── memory.db              # Global vector DB
+│   ├── memory.db              # Global vector DB (SQLite fallback)
 │   └── *.md                   # Global memory files
 └── <project_name>/
-    ├── memory.db              # Project vector DB
+    ├── memory.db              # Project vector DB (SQLite fallback)
     └── *.md                   # Project memory files
+
+~/.mempalace/palace/             # MemPalace palace (primary backend)
+```
+
+## MemPalace backend
+
+On first load, the memory package:
+1. Detects MemPalace; if missing and `uv` is available, runs
+   `uv tool install mempalace` once (caches the venv python path in
+   `~/.unipi/memory/.mempalace-install`).
+2. Pings the bridge to confirm the palace is usable.
+3. If `~/.unipi/memory/.mempalace-migrated` is absent, performs a one-way
+   read-only migration of every legacy memory (SQLite rows + markdown files
+   across all projects) into MemPalace drawers, then writes the flag.
+   Migration is idempotent (deterministic drawer IDs) and never deletes or
+   mutates legacy files.
+
+Each memory operation invokes a bundled Python bridge
+(`bridge/mempalace_bridge.py`) once via `spawnSync` (~0.5s per call). The
+first MemPalace use on a machine also downloads the default ONNX embedding
+model (~80MB, cached at `~/.cache/chroma/onnx_models/`).
+
+### Forcing re-detection / re-migration
+
+```bash
+rm ~/.unipi/memory/.mempalace-install    # re-detect MemPalace next session
+rm ~/.unipi/memory/.mempalace-migrated   # re-run one-way migration next session
 ```
 
+### Backend override
+
+Set `UNIPI_MEMPALACE_BACKEND` to force a MemPalace backend
+(`sqlite_exact`, `qdrant`, `pgvector`, default `chroma`).
+
+### Embedder identity
+
+MemPalace enforces embedder identity. If a palace was created with a
+different embedding model, writes are rejected — the package then falls
+back to SQLite for that session. Use `mempalace palace set-embedder`
+intentionally to realign, then remove the install cache to re-detect.
+
 ## Dependencies
 
-- `better-sqlite3` — SQLite database
-- `sqlite-vec` — Vector search extension
+- `mempalace` (Python, auto-installed via `uv`) — primary backend
+- `better-sqlite3` — SQLite fallback database
+- `sqlite-vec` — Vector search extension (fallback)
 - `js-yaml` — YAML frontmatter parsing
 - `@pi-unipi/core` — Shared utilities
 

package/bridge/mempalace_bridge.py

@@ -0,0 +1,556 @@
+#!/usr/bin/env python3
+"""UniPi memory <-> MemPalace bridge.
+
+Single-command JSON bridge invoked once per operation by the TypeScript
+memory package. Loads MemPalace, opens the palace collection, performs one
+command, prints one JSON line to stdout, exits.
+
+Usage:
+    python mempalace_bridge.py <palace_path> <command> [args_json]
+
+stdout (always exactly one JSON line):
+    {"ok": true, "result": <value>}
+    {"ok": false, "error": "<message>"}
+
+Design notes:
+- MemPalace embeds drawer text internally (default ONNX MiniLM model). UniPi
+  never passes embeddings through this bridge; search uses query_texts.
+- Drawer documents are markdown with YAML frontmatter so the human-readable
+  tier is preserved and the bridge can recover title/type without metadata.
+- Drawer IDs are deterministic via make_drawer_id_from_chunk(wing, room,
+  source_uri, 0), so upserts are idempotent and re-migration does not
+  duplicate records.
+- Metadata is kept scalar/string-only for backend portability (ChromaDB,
+  sqlite_exact, qdrant, pgvector).
+- This script never deletes or mutates UniPi legacy files; migration is a
+  read-only copy into MemPalace.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import re
+import sqlite3
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Iterable
+
+try:
+    import yaml  # type: ignore
+except Exception:  # pragma: no cover
+    yaml = None
+
+MEMORY_TYPES = {"preference", "decision", "pattern", "summary"}
+MIGRATION_AGENT = "unipi-memory-bridge"
+
+
+# ---------------------------------------------------------------------------
+# ID + URI helpers (mirror mempalace.ids when available, else deterministic fallback)
+# ---------------------------------------------------------------------------
+
+def quote_uri_part(value: str) -> str:
+    return re.sub(r"[^A-Za-z0-9_.~-]", lambda m: f"%{ord(m.group(0)):02X}", value)
+
+
+def safe_id_part(value: str) -> str:
+    cleaned = re.sub(r"[^A-Za-z0-9]+", "_", value).strip("_").lower()
+    return cleaned or "unknown"
+
+
+def stable_hash(parts: Iterable[Any], length: int = 24) -> str:
+    payload = "".join(f"{len(str(part))}:{part}" for part in parts).encode("utf-8")
+    return hashlib.sha256(payload).hexdigest()[:length]
+
+
+def fallback_drawer_id(wing: str, room: str, source_file: str, chunk_index: int = 0) -> str:
+    return (
+        f"drawer_{safe_id_part(wing)}_{safe_id_part(room)}_"
+        f"{stable_hash((source_file, str(chunk_index)))}"
+    )
+
+
+def drawer_id_for(wing: str, room: str, source_uri: str, chunk_index: int = 0) -> str:
+    try:
+        from mempalace.ids import make_drawer_id_from_chunk  # type: ignore
+        return make_drawer_id_from_chunk(wing, room, source_uri, chunk_index)
+    except Exception:
+        return fallback_drawer_id(wing, room, source_uri, chunk_index)
+
+
+# ---------------------------------------------------------------------------
+# Frontmatter (YAML when available, minimal fallback otherwise)
+# ---------------------------------------------------------------------------
+
+def dump_frontmatter(data: dict[str, Any]) -> str:
+    if yaml is not None:
+        return yaml.safe_dump(data, sort_keys=False, allow_unicode=True, width=10_000)
+    lines: list[str] = []
+    for key, value in data.items():
+        if isinstance(value, list):
+            lines.append(f"{key}:")
+            lines.extend(f"  - {item}" for item in value)
+        else:
+            lines.append(f"{key}: {value}")
+    return "\n".join(lines) + "\n"
+
+
+def parse_frontmatter(text: str) -> tuple[dict[str, Any], str] | None:
+    if not text.startswith("---\n"):
+        return None
+    end = text.find("\n---", 4)
+    if end == -1:
+        return None
+    raw_fm = text[4:end]
+    body_start = end + len("\n---")
+    if text[body_start : body_start + 1] == "\n":
+        body_start += 1
+    body = text[body_start:]
+    if yaml is not None:
+        loaded = yaml.safe_load(raw_fm) or {}
+        if not isinstance(loaded, dict):
+            return None
+        return loaded, body
+    # minimal fallback parser
+    data: dict[str, Any] = {}
+    current_list_key: str | None = None
+    for raw_line in raw_fm.splitlines():
+        line = raw_line.rstrip()
+        if not line:
+            continue
+        if current_list_key and line.startswith("  - "):
+            data.setdefault(current_list_key, []).append(line[4:].strip().strip("'\""))
+            continue
+        current_list_key = None
+        if ":" not in line:
+            continue
+        key, value = line.split(":", 1)
+        key = key.strip()
+        value = value.strip()
+        if value == "":
+            data[key] = []
+            current_list_key = key
+        elif value.startswith("[") and value.endswith("]"):
+            data[key] = [v.strip().strip("'\"") for v in value[1:-1].split(",") if v.strip()]
+        else:
+            data[key] = value.strip("'\"")
+    return data, body
+
+
+def coerce_tags(value: Any) -> list[str]:
+    if value is None:
+        return []
+    if isinstance(value, list):
+        return [str(v) for v in value if str(v).strip()]
+    if isinstance(value, str):
+        stripped = value.strip()
+        if not stripped:
+            return []
+        try:
+            parsed = json.loads(stripped)
+            if isinstance(parsed, list):
+                return [str(v) for v in parsed if str(v).strip()]
+        except Exception:
+            pass
+        return [part.strip() for part in stripped.split(",") if part.strip()]
+    return [str(value)]
+
+
+def normalize_type(value: Any) -> str:
+    lowered = str(value or "summary").strip().lower()
+    return lowered if lowered in MEMORY_TYPES else "summary"
+
+
+def build_document(title: str, content: str, tags: list[str], project: str,
+                   created: str, updated: str, mtype: str, unipi_id: str) -> str:
+    fm = {
+        "title": title,
+        "tags": tags,
+        "project": project,
+        "created": created,
+        "updated": updated,
+        "type": mtype,
+        "unipi_id": unipi_id,
+    }
+    fm = {k: v for k, v in fm.items() if v not in (None, [], "")}
+    return f"---\n{dump_frontmatter(fm)}---\n\n{content.strip()}\n"
+
+
+def build_metadata(wing: str, room: str, title: str, mtype: str, project: str,
+                   tags: list[str], unipi_id: str, source_kind: str, now: str,
+                   content_date: str = "") -> dict[str, Any]:
+    return {
+        "wing": wing,
+        "room": room,
+        "source_file": f"unipi://memory/{quote_uri_part(project)}/{quote_uri_part(unipi_id)}",
+        "chunk_index": 0,
+        "added_by": MIGRATION_AGENT,
+        "filed_at": now,
+        "content_date": content_date,
+        "unipi_project": project,
+        "unipi_id": unipi_id,
+        "unipi_title": title,
+        "unipi_type": mtype,
+        "unipi_tags": ",".join(tags),
+        "unipi_source_kind": source_kind,
+        "normalize_version": 2,
+        "id_recipe": "unipi-bridge-v1",
+    }
+
+
+def record_from_doc(doc: str, meta: dict[str, Any] | None) -> dict[str, Any] | None:
+    """Recover a UniPi-style record from a drawer document + metadata."""
+    parsed = parse_frontmatter(doc) if doc else None
+    fm: dict[str, Any] = {}
+    body = doc or ""
+    if parsed:
+        fm, body = parsed
+    meta = meta or {}
+    unipi_id = fm.get("unipi_id") or meta.get("unipi_id") or ""
+    if not unipi_id:
+        # fall back to drawer id if metadata lost
+        return None
+    title = str(fm.get("title") or meta.get("unipi_title") or unipi_id)
+    return {
+        "id": unipi_id,
+        "title": title,
+        "content": body.strip(),
+        "tags": coerce_tags(fm.get("tags") if "tags" in fm else meta.get("unipi_tags")),
+        "project": str(fm.get("project") or meta.get("unipi_project") or meta.get("wing") or ""),
+        "type": normalize_type(fm.get("type") or meta.get("unipi_type")),
+        "created": str(fm.get("created") or ""),
+        "updated": str(fm.get("updated") or ""),
+    }
+
+
+def snippet(text: str, length: int = 200) -> str:
+    text = (text or "").strip().replace("\n", " ")
+    return text[:length] + ("..." if len(text) > length else "")
+
+
+# ---------------------------------------------------------------------------
+# Legacy UniPi source reading (read-only)
+# ---------------------------------------------------------------------------
+
+def parse_markdown_memory(project: str, path: Path) -> dict[str, Any] | None:
+    try:
+        text = path.read_text(encoding="utf-8")
+    except UnicodeDecodeError:
+        text = path.read_text(encoding="utf-8", errors="replace")
+    except OSError:
+        return None
+    parsed = parse_frontmatter(text)
+    if parsed is None:
+        return None
+    fm, body = parsed
+    mid = safe_id_part(str(fm.get("id") or path.stem))
+    return {
+        "project": str(fm.get("project") or project),
+        "id": mid,
+        "title": str(fm.get("title") or path.stem).strip(),
+        "content": body.strip(),
+        "tags": coerce_tags(fm.get("tags")),
+        "type": normalize_type(fm.get("type")),
+        "created": str(fm.get("created")) if fm.get("created") else "",
+        "updated": str(fm.get("updated")) if fm.get("updated") else "",
+        "source_kind": "markdown",
+        "source_path": str(path),
+    }
+
+
+def load_sqlite_memories(project: str, db_path: Path) -> list[dict[str, Any]]:
+    if not db_path.exists():
+        return []
+    uri = f"file:{db_path}?mode=ro"
+    try:
+        conn = sqlite3.connect(uri, uri=True, timeout=10)
+        conn.row_factory = sqlite3.Row
+        try:
+            rows = list(conn.execute("SELECT * FROM memories"))
+        finally:
+            conn.close()
+    except sqlite3.DatabaseError:
+        return []
+    out: list[dict[str, Any]] = []
+    for row in rows:
+        out.append({
+            "project": str(row["project"] or project),
+            "id": safe_id_part(str(row["id"] or row["title"])),
+            "title": str(row["title"] or row["id"]),
+            "content": str(row["content"] or "").strip(),
+            "tags": coerce_tags(row["tags"]),
+            "type": normalize_type(row["type"]),
+            "created": str(row["created"]) if row["created"] else "",
+            "updated": str(row["updated"]) if row["updated"] else "",
+            "source_kind": "sqlite",
+            "source_path": str(db_path),
+        })
+    return out
+
+
+def discover_legacy_memories(source_dir: Path, project_filter: list[str] | None = None) -> list[dict[str, Any]]:
+    if not source_dir.exists():
+        return []
+    filters = set(project_filter or [])
+    by_key: dict[tuple[str, str], dict[str, Any]] = {}
+    for project_dir in sorted(p for p in source_dir.iterdir() if p.is_dir()):
+        project = project_dir.name
+        if filters and project not in filters:
+            continue
+        for md_path in sorted(project_dir.glob("*.md")):
+            if md_path.name.startswith("."):
+                continue
+            rec = parse_markdown_memory(project, md_path)
+            if rec:
+                by_key[(rec["project"], rec["id"])] = rec
+        for rec in load_sqlite_memories(project, project_dir / "memory.db"):
+            by_key.setdefault((rec["project"], rec["id"]), rec)
+    return sorted(by_key.values(), key=lambda r: (r["project"], r["type"], r["title"], r["id"]))
+
+
+# ---------------------------------------------------------------------------
+# Bridge session
+# ---------------------------------------------------------------------------
+
+class Bridge:
+    def __init__(self, palace_path: str, backend: str | None = None):
+        from mempalace.palace import get_collection  # type: ignore
+        kwargs: dict[str, Any] = {"create": True}
+        if backend:
+            kwargs["backend"] = backend
+        self.palace_path = palace_path
+        self.collection = get_collection(palace_path, **kwargs)
+
+    def _now(self) -> str:
+        return datetime.now(timezone.utc).isoformat()
+
+    def _wing_room(self, project: str, mtype: str) -> tuple[str, str]:
+        return project, f"unipi_{normalize_type(mtype)}"
+
+    def _source_uri(self, project: str, unipi_id: str) -> str:
+        return f"unipi://memory/{quote_uri_part(project)}/{quote_uri_part(unipi_id)}"
+
+    def _upsert_one(self, rec: dict[str, Any], wing: str | None = None, room: str | None = None) -> str:
+        wing = wing or rec["project"]
+        room = room or f"unipi_{normalize_type(rec['type'])}"
+        source_uri = self._source_uri(rec["project"], rec["id"])
+        did = drawer_id_for(wing, room, source_uri, 0)
+        doc = build_document(
+            rec["title"], rec["content"], rec["tags"], rec["project"],
+            rec.get("created", ""), rec.get("updated", ""), rec["type"], rec["id"],
+        )
+        meta = build_metadata(
+            wing, room, rec["title"], rec["type"], rec["project"], rec["tags"],
+            rec["id"], rec.get("source_kind", "markdown"), self._now(),
+            rec.get("updated") or rec.get("created") or "",
+        )
+        self.collection.upsert(documents=[doc], ids=[did], metadatas=[meta])
+        return did
+
+    # -- commands --
+
+    def ping(self) -> str:
+        return "pong"
+
+    def count(self, wing: str | None = None) -> int:
+        if wing:
+            got = self.collection.get(where={"wing": wing})
+        else:
+            got = self.collection.get()
+        return len(got.ids if hasattr(got, "ids") else got.get("ids", []))
+
+    def store(self, record: dict[str, Any]) -> dict[str, Any]:
+        did = self._upsert_one(record)
+        return {"id": record["id"], "drawer_id": did}
+
+    def get(self, id_: str) -> dict[str, Any] | None:
+        # IDs in metadata are unipi ids; fetch all and filter (drawer ids differ).
+        got = self.collection.get(where={"unipi_id": id_})
+        ids = got.ids if hasattr(got, "ids") else got.get("ids", [])
+        docs = got.documents if hasattr(got, "documents") else got.get("documents", [])
+        metas = got.metadatas if hasattr(got, "metadatas") else got.get("metadatas", [])
+        if not ids:
+            return None
+        return record_from_doc(docs[0], metas[0] if metas else None)
+
+    def get_by_title(self, wing: str, title: str) -> dict[str, Any] | None:
+        got = self.collection.get(where={"wing": wing})
+        docs = got.documents if hasattr(got, "documents") else got.get("documents", [])
+        metas = got.metadatas if hasattr(got, "metadatas") else got.get("metadatas", [])
+        lowered = title.lower()
+        for doc, meta in zip(docs, metas):
+            rec = record_from_doc(doc, meta)
+            if not rec:
+                continue
+            if rec["title"] == title or rec["title"].lower() == lowered:
+                return rec
+        return None
+
+    def list(self, wing: str) -> list[dict[str, Any]]:
+        got = self.collection.get(where={"wing": wing})
+        docs = got.documents if hasattr(got, "documents") else got.get("documents", [])
+        metas = got.metadatas if hasattr(got, "metadatas") else got.get("metadatas", [])
+        out: list[dict[str, Any]] = []
+        for doc, meta in zip(docs, metas):
+            rec = record_from_doc(doc, meta)
+            if rec:
+                out.append({"id": rec["id"], "title": rec["title"], "type": rec["type"]})
+        # sort by updated desc (best effort — metadata has no guaranteed order)
+        return out
+
+    def list_all(self) -> list[dict[str, Any]]:
+        got = self.collection.get()
+        docs = got.documents if hasattr(got, "documents") else got.get("documents", [])
+        metas = got.metadatas if hasattr(got, "metadatas") else got.get("metadatas", [])
+        out: list[dict[str, Any]] = []
+        for doc, meta in zip(docs, metas):
+            rec = record_from_doc(doc, meta)
+            if rec:
+                out.append({"id": rec["id"], "title": rec["title"], "type": rec["type"],
+                            "project": rec["project"]})
+        return out
+
+    def search(self, query: str, wing: str | None = None, limit: int = 10) -> list[dict[str, Any]]:
+        where = {"wing": wing} if wing else None
+        kwargs: dict[str, Any] = {"query_texts": [query], "n_results": limit}
+        if where:
+            kwargs["where"] = where
+        res = self.collection.query(**kwargs)
+        ids = res.ids[0] if res.ids else []
+        docs = res.documents[0] if res.documents else []
+        metas = res.metadatas[0] if res.metadatas else []
+        dists = res.distances[0] if res.distances else []
+        out: list[dict[str, Any]] = []
+        for doc, meta, dist in zip(docs, metas, dists):
+            rec = record_from_doc(doc, meta)
+            if not rec:
+                continue
+            score = max(0.0, 1.0 - float(dist))
+            out.append({
+                "id": rec["id"], "title": rec["title"], "content": rec["content"],
+                "tags": rec["tags"], "project": rec["project"], "type": rec["type"],
+                "created": rec["created"], "updated": rec["updated"],
+                "score": round(score, 4), "snippet": snippet(rec["content"]),
+            })
+        return out
+
+    def delete(self, id_: str) -> bool:
+        got = self.collection.get(where={"unipi_id": id_})
+        ids = got.ids if hasattr(got, "ids") else got.get("ids", [])
+        if not ids:
+            return False
+        self.collection.delete(ids=ids)
+        return True
+
+    def has_title(self, wing: str, title: str) -> bool:
+        return self.get_by_title(wing, title) is not None
+
+    def find_similar(self, wing: str, title: str, threshold: float = 0.6) -> list[dict[str, Any]]:
+        got = self.collection.get(where={"wing": wing})
+        docs = got.documents if hasattr(got, "documents") else got.get("documents", [])
+        metas = got.metadatas if hasattr(got, "metadatas") else got.get("metadatas", [])
+        norm = re.sub(r"[^a-z0-9]+", " ", title.lower())
+        title_words = set(w for w in norm.split() if len(w) > 2)
+        out: list[dict[str, Any]] = []
+        for doc, meta in zip(docs, metas):
+            rec = record_from_doc(doc, meta)
+            if not rec:
+                continue
+            rnorm = re.sub(r"[^a-z0-9]+", " ", rec["title"].lower())
+            rwords = set(w for w in re.split(r"\s+", rnorm) if len(w) > 2)
+            union = title_words | rwords
+            inter = title_words & rwords
+            sim = len(inter) / len(union) if union else 0.0
+            if sim >= threshold:
+                out.append({"record": rec, "similarity": round(sim, 4)})
+        out.sort(key=lambda x: x["similarity"], reverse=True)
+        return out
+
+    def sync_orphaned(self, project_dir: str, wing: str) -> int:
+        pdir = Path(project_dir)
+        if not pdir.exists():
+            return 0
+        existing = {r["id"] for r in self.list(wing)}
+        synced = 0
+        for md_path in sorted(pdir.glob("*.md")):
+            if md_path.name.startswith("."):
+                continue
+            rec = parse_markdown_memory(wing, md_path)
+            if not rec:
+                continue
+            if rec["id"] in existing:
+                continue
+            self._upsert_one(rec)
+            synced += 1
+        return synced
+
+    def migrate(self, source_dir: str, project_filter: list[str] | None = None) -> dict[str, Any]:
+        records = discover_legacy_memories(Path(source_dir), project_filter)
+        imported = 0
+        by_project: dict[str, int] = {}
+        for rec in records:
+            try:
+                self._upsert_one(rec)
+                imported += 1
+                by_project[rec["project"]] = by_project.get(rec["project"], 0) + 1
+            except Exception:
+                pass
+        return {"imported": imported, "projects": by_project}
+
+
+# ---------------------------------------------------------------------------
+# Entry point
+# ---------------------------------------------------------------------------
+
+def main(argv: list[str]) -> int:
+    if len(argv) < 3:
+        print(json.dumps({"ok": False, "error": "usage: bridge.py <palace> <command> [args_json]"}))
+        return 2
+    palace = argv[1]
+    cmd = argv[2]
+    args_raw = argv[3] if len(argv) > 3 else "{}"
+    try:
+        args = json.loads(args_raw) if args_raw else {}
+    except json.JSONDecodeError as exc:
+        print(json.dumps({"ok": False, "error": f"invalid args json: {exc}"}))
+        return 2
+
+    backend = os.environ.get("UNIPI_MEMPALACE_BACKEND") or None
+    try:
+        bridge = Bridge(palace, backend=backend)
+    except Exception as exc:
+        print(json.dumps({"ok": False, "error": f"mempalace init failed: {type(exc).__name__}: {exc}"}))
+        return 1
+
+    handlers = {
+        "ping": lambda: bridge.ping(),
+        "count": lambda: bridge.count(args.get("wing")),
+        "store": lambda: bridge.store(args["record"]),
+        "get": lambda: bridge.get(args["id"]),
+        "get_by_title": lambda: bridge.get_by_title(args["wing"], args["title"]),
+        "list": lambda: bridge.list(args["wing"]),
+        "list_all": lambda: bridge.list_all(),
+        "search": lambda: bridge.search(args["query"], args.get("wing"), int(args.get("limit", 10))),
+        "delete": lambda: bridge.delete(args["id"]),
+        "has_title": lambda: bridge.has_title(args["wing"], args["title"]),
+        "find_similar": lambda: bridge.find_similar(args["wing"], args["title"], float(args.get("threshold", 0.6))),
+        "sync_orphaned": lambda: bridge.sync_orphaned(args["project_dir"], args["wing"]),
+        "migrate": lambda: bridge.migrate(args["source_dir"], args.get("projects")),
+    }
+    handler = handlers.get(cmd)
+    if handler is None:
+        print(json.dumps({"ok": False, "error": f"unknown command: {cmd}"}))
+        return 2
+    try:
+        result = handler()
+        print(json.dumps({"ok": True, "result": result}, default=str))
+        return 0
+    except Exception as exc:
+        print(json.dumps({"ok": False, "error": f"{type(exc).__name__}: {exc}"}))
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv))

package/index.ts

@@ -7,6 +7,8 @@
  * Auto-consolidates on compaction.
  */
 
+import { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import {
   UNIPI_EVENTS,
@@ -30,7 +32,7 @@ import { registerMemoryCommands } from "./commands.js";
 import { isEmbeddingReady, hasModelChanged } from "./settings.js";
 
 /** Package version */
-const VERSION = getPackageVersion(new URL(".", import.meta.url).pathname);
+const VERSION = getPackageVersion(dirname(fileURLToPath(import.meta.url)));
 
 /** Storage instance for current project */
 let projectStorage: MemoryStorage | null = null;
@@ -51,14 +53,6 @@ export default function (pi: ExtensionAPI) {
   let recallDone = false;
   let storeDone = false;
 
-  // Register skills directory
-  const skillsDir = new URL("./skills", import.meta.url).pathname;
-  pi.on("resources_discover", async (_event, _ctx) => {
-    return {
-      skillPaths: [skillsDir],
-    };
-  });
-
   // Register tools and commands
   registerMemoryTools(pi, getStorage, {
     onRecall: () => { recallDone = true; },
@@ -178,11 +172,12 @@ export default function (pi: ExtensionAPI) {
       } catch (_err) {
         // Count unavailable — status bar shows 0.
       }
-      const vecReady = isEmbeddingReady();
-      const vecIcon = vecReady ? "⚡" : "📝";
+      const mempalaceActive = projectStorage?.isMempalace() ?? false;
+      const backendIcon = mempalaceActive ? "🧠" : (isEmbeddingReady() ? "⚡" : "📝");
+      const warn = hasModelChanged() ? " ⚠" : "";
       ctx.ui.setStatus(
         "unipi-memory",
-        `${vecIcon} mem ${projectCount}p/${projectCountAll}all${hasModelChanged() ? " ⚠" : ""}`
+        `${backendIcon} mem ${projectCount}p/${projectCountAll}all${warn}`
       );
     }
   });

package/mempalace.ts

@@ -0,0 +1,232 @@
+/**
+ * @unipi/memory — MemPalace backend client
+ *
+ * Detects and auto-installs MemPalace (via uv), then invokes the bundled
+ * Python bridge (bridge/mempalace_bridge.py) once per operation using the
+ * MemPalace venv python. Each call is a synchronous spawnSync that prints
+ * one JSON line.
+ *
+ * If MemPalace or uv is unavailable, all operations return null so the
+ * storage layer can fall back to the legacy SQLite path. Memory must never
+ * hard-fail because the backend is missing.
+ */
+
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import { fileURLToPath } from "node:url";
+
+/** Default MemPalace palace path. */
+export const DEFAULT_PALACE = path.join(os.homedir(), ".mempalace", "palace");
+
+const INSTALL_FLAG = path.join(os.homedir(), ".unipi", "memory", ".mempalace-install");
+const MIGRATED_FLAG = path.join(os.homedir(), ".unipi", "memory", ".mempalace-migrated");
+
+/** Path to the bundled bridge script. */
+const BRIDGE_PATH = path.join(dirname(fileURLToPath(import.meta.url)), "bridge", "mempalace_bridge.py");
+
+function dirname(p: string): string {
+  return path.dirname(p);
+}
+
+export interface BridgeResponse<T> {
+  ok: boolean;
+  result?: T;
+  error?: string;
+}
+
+export interface MempalaceRecord {
+  id: string;
+  title: string;
+  content: string;
+  tags: string[];
+  project: string;
+  type: "preference" | "decision" | "pattern" | "summary";
+  created: string;
+  updated: string;
+}
+
+export interface MempalaceSearchResult extends MempalaceRecord {
+  score: number;
+  snippet: string;
+}
+
+export interface MempalaceListItem {
+  id: string;
+  title: string;
+  type: string;
+}
+
+export interface MempalaceListItemAll extends MempalaceListItem {
+  project: string;
+}
+
+export interface MempalaceInstall {
+  python: string;
+  version: string;
+}
+
+/** Check whether a binary is on PATH. */
+function which(bin: string): string | null {
+  try {
+    const res = spawnSync(bin, ["--version"], { encoding: "utf-8", timeout: 5000 });
+    if (res.status === 0 || res.stdout || res.stderr) return bin;
+  } catch { /* ignore */ }
+  // Fallback: `which`
+  try {
+    const res = spawnSync("which", [bin], { encoding: "utf-8" });
+    if (res.status === 0) return res.stdout.trim() || null;
+  } catch { /* ignore */ }
+  return null;
+}
+
+/**
+ * Locate the MemPalace venv python after a `uv tool install mempalace`.
+ * Uses `uv tool dir` to find the venv root.
+ */
+function findVenvPython(): string | null {
+  try {
+    const res = spawnSync("uv", ["tool", "dir"], { encoding: "utf-8", timeout: 5000 });
+    if (res.status !== 0 || !res.stdout.trim()) return null;
+    const candidate = path.join(res.stdout.trim(), "mempalace", "bin", "python");
+    if (fs.existsSync(candidate)) return candidate;
+    // Some platforms use Scripts/ on Windows — not relevant here but be safe.
+    const win = path.join(res.stdout.trim(), "mempalace", "Scripts", "python.exe");
+    if (fs.existsSync(win)) return win;
+  } catch { /* ignore */ }
+  return null;
+}
+
+/** Read a cached install record. */
+function readCachedInstall(): MempalaceInstall | null {
+  try {
+    if (fs.existsSync(INSTALL_FLAG)) {
+      const parsed = JSON.parse(fs.readFileSync(INSTALL_FLAG, "utf-8"));
+      if (parsed && parsed.python && fs.existsSync(parsed.python)) {
+        return parsed;
+      }
+    }
+  } catch { /* ignore */ }
+  return null;
+}
+
+/** Persist an install record so we don't re-detect every session. */
+function writeCachedInstall(install: MempalaceInstall): void {
+  try {
+    fs.mkdirSync(path.dirname(INSTALL_FLAG), { recursive: true });
+    fs.writeFileSync(INSTALL_FLAG, JSON.stringify(install, null, 2), "utf-8");
+  } catch { /* ignore */ }
+}
+
+/** Detect mempalace version via the venv python. */
+function detectVersion(python: string): string {
+  try {
+    const res = spawnSync(python, ["-c", "import mempalace; print(getattr(mempalace,'__version__','unknown'))"], { encoding: "utf-8", timeout: 5000 });
+    return (res.stdout || "").trim() || "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+
+/**
+ * Ensure MemPalace is installed and return the venv python path.
+ * Auto-installs via `uv tool install mempalace` if missing and uv is
+ * available. Returns null if MemPalace cannot be made available (caller
+ * should fall back to legacy SQLite storage).
+ */
+export function ensureMempalace(): MempalaceInstall | null {
+  const cached = readCachedInstall();
+  if (cached) return cached;
+
+  // 1. Already installed via uv tool? Locate venv python.
+  let python = findVenvPython();
+
+  // 2. If not, and uv is available, install it.
+  if (!python && which("uv")) {
+    try {
+      const res = spawnSync("uv", ["tool", "install", "mempalace"], {
+        encoding: "utf-8",
+        timeout: 180_000, // first install downloads deps + embedding model
+      });
+      if (res.status === 0) {
+        python = findVenvPython();
+      }
+    } catch { /* ignore — fall back */ }
+  }
+
+  if (!python) return null;
+
+  const version = detectVersion(python);
+  const install = { python, version };
+  writeCachedInstall(install);
+  return install;
+}
+
+/** Drop the cached install record (forces re-detection next session). */
+export function invalidateInstallCache(): void {
+  try { if (fs.existsSync(INSTALL_FLAG)) fs.unlinkSync(INSTALL_FLAG); } catch { /* ignore */ }
+}
+
+/** Has the one-way legacy migration been completed? */
+export function isMigrated(): boolean {
+  return fs.existsSync(MIGRATED_FLAG);
+}
+
+/** Mark the one-way legacy migration complete. */
+export function markMigrated(): void {
+  try {
+    fs.mkdirSync(path.dirname(MIGRATED_FLAG), { recursive: true });
+    fs.writeFileSync(MIGRATED_FLAG, new Date().toISOString(), "utf-8");
+  } catch { /* ignore */ }
+}
+
+/** Force re-migration by clearing the flag. */
+export function clearMigratedFlag(): void {
+  try { if (fs.existsSync(MIGRATED_FLAG)) fs.unlinkSync(MIGRATED_FLAG); } catch { /* ignore */ }
+}
+
+/**
+ * Run one bridge command synchronously. Returns the parsed result, or null
+ * on any failure (timeout, non-zero exit, bad JSON, ok=false).
+ */
+export function runBridge<T = unknown>(
+  install: MempalaceInstall,
+  palace: string,
+  cmd: string,
+  args: Record<string, unknown> = {},
+): T | null {
+  let argsJson: string;
+  try {
+    argsJson = JSON.stringify(args);
+  } catch {
+    return null;
+  }
+  let res;
+  try {
+    res = spawnSync(install.python, [BRIDGE_PATH, palace, cmd, argsJson], {
+      encoding: "utf-8",
+      timeout: 60_000,
+      maxBuffer: 64 * 1024 * 1024,
+    });
+  } catch {
+    return null;
+  }
+  if (res.error || res.status !== 0) {
+    return null;
+  }
+  const out = (res.stdout || "").trim();
+  if (!out) return null;
+  try {
+    const parsed = JSON.parse(out) as BridgeResponse<T>;
+    if (!parsed.ok) return null;
+    return (parsed.result ?? null) as T | null;
+  } catch {
+    return null;
+  }
+}
+
+/** Ping the bridge — returns true if the backend is alive. */
+export function ping(install: MempalaceInstall, palace: string): boolean {
+  return runBridge<string>(install, palace, "ping") === "pong";
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@pi-unipi/memory",
-  "version": "2.0.12",
-  "description": "Persistent cross-session memory with vector search for Pi coding agent",
+  "version": "2.1.0",
+  "description": "Persistent cross-session memory with MemPalace backend (auto-installed) and SQLite fallback for Pi coding agent",
   "type": "module",
   "main": "index.ts",
   "license": "MIT",
@@ -21,6 +21,7 @@
     "pi-coding-agent",
     "unipi",
     "memory",
+    "mempalace",
     "vector-search",
     "sqlite-vec"
   ],
@@ -32,6 +33,8 @@
     "settings.ts",
     "tools.ts",
     "commands.ts",
+    "mempalace.ts",
+    "bridge/mempalace_bridge.py",
     "tui/**/*",
     "skills/**/*",
     "README.md"
@@ -40,11 +43,11 @@
     "better-sqlite3": "^12.9.0",
     "sqlite-vec": "^0.1.9",
     "js-yaml": "^4.1.0",
-    "@pi-unipi/core": "2.0.12",
-    "@pi-unipi/info-screen": "2.0.12"
+    "@pi-unipi/core": "2.1.0",
+    "@pi-unipi/info-screen": "2.1.0"
   },
   "peerDependencies": {
-    "@earendil-works/pi-coding-agent": "^0.78.0",
+    "@earendil-works/pi-coding-agent": "^0.80.0",
     "typebox": "^1.1.38"
   },
   "devDependencies": {

package/storage.ts

@@ -1,8 +1,10 @@
 /**
  * @unipi/memory — Storage layer
  *
- * Two-tier storage: SQLite + sqlite-vec for vector search,
- * markdown files for human-readable memory.
+ * Primary backend: MemPalace (auto-installed via uv, auto-migrated from
+ * legacy data). Falls back to SQLite + sqlite-vec when MemPalace/uv is
+ * unavailable, so memory never hard-fails. Markdown files remain the
+ * durable human-readable tier and the migration source.
  */
 
 import Database from "better-sqlite3";
@@ -12,6 +14,44 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import * as os from "node:os";
 import { randomUUID } from "node:crypto";
+import {
+  ensureMempalace,
+  runBridge,
+  isMigrated,
+  markMigrated,
+  DEFAULT_PALACE,
+  type MempalaceInstall,
+  type MempalaceRecord,
+  type MempalaceSearchResult,
+  type MempalaceListItem,
+  type MempalaceListItemAll,
+} from "./mempalace.js";
+
+export type MemoryBackend = "mempalace" | "sqlite";
+
+/** Convert a MemPalace record (plain JSON) into a MemoryRecord. */
+function toMemoryRecord(r: MempalaceRecord): MemoryRecord {
+  return {
+    id: r.id,
+    title: r.title,
+    content: r.content,
+    tags: Array.isArray(r.tags) ? r.tags : [],
+    project: r.project,
+    type: (r.type as MemoryRecord["type"]) || "summary",
+    created: r.created || "",
+    updated: r.updated || "",
+    embedding: null,
+  };
+}
+
+/** Whether MemPalace is detectable on this machine (for status display). */
+export function isMempalaceAvailable(): boolean {
+  try {
+    return ensureMempalace() !== null;
+  } catch {
+    return false;
+  }
+}
 
 /** Memory row from SQLite queries */
 interface MemoryRow {
@@ -203,27 +243,43 @@ export class MemoryStorage {
   private db: Database.Database | null = null;
   private projectName: string;
   private scopeDir: string;
+  private backend: MemoryBackend = "sqlite";
+  private mempalaceInstall: MempalaceInstall | null = null;
+  private palacePath: string = DEFAULT_PALACE;
 
   constructor(projectName: string) {
     this.projectName = projectName;
     this.scopeDir = getProjectDir(projectName);
   }
 
+  /** Active backend ("mempalace" when available, else "sqlite"). */
+  getBackend(): MemoryBackend {
+    return this.backend;
+  }
+
+  /** True when the MemPalace backend is active for this instance. */
+  isMempalace(): boolean {
+    return this.backend === "mempalace" && this.mempalaceInstall !== null;
+  }
+
   /**
-   * Initialize the storage (create DB, tables, load extension).
-   *
-   * Uses retry logic to handle concurrent access from multiple Pi sessions,
-   * especially on WSL/Windows filesystem where SQLite locking can be flaky.
-   *
-   * IMPORTANT: We never delete the DB here — another session may have it open.
-   * If all retries fail, we throw and let this session run without memory.
+   * Initialize storage. Tries MemPalace first (auto-install + one-way
+   * auto-migration of legacy memories); falls back to SQLite if MemPalace
+   * is unavailable. Never throws for backend unavailability — only throws
+   * if the SQLite fallback itself fails to open.
    */
   init(): void {
-    // Ensure directory exists
+    // Ensure directory exists (used by both backends for markdown tier).
     if (!fs.existsSync(this.scopeDir)) {
       fs.mkdirSync(this.scopeDir, { recursive: true });
     }
 
+    if (this.tryInitMempalace()) {
+      return;
+    }
+
+    // Fallback: SQLite + sqlite-vec.
+    this.backend = "sqlite";
     const dbPath = path.join(this.scopeDir, MEMORY_DB_NAME);
     const maxRetries = 5;
 
@@ -243,27 +299,54 @@ export class MemoryStorage {
         this.close();
 
         if (isTransient && attempt < maxRetries) {
-          // Likely concurrent access — back off and retry.
-          // Do NOT delete the DB: another session may have it open
-          // and deleting open files on WSL/Windows is unsafe.
           const delayMs = 50 * Math.pow(2, attempt - 1); // 50, 100, 200, 400
-          // Removed console.warn — transient retries are normal during concurrent access.
-          // Memory availability visible via info-screen memory group.
           const end = Date.now() + delayMs;
           while (Date.now() < end) { /* busy wait */ }
           continue;
         }
 
-        // Either non-transient error, or retries exhausted.
-        // Log and throw — this session will run without memory.
-        if (isTransient) {
-          // Removed console.warn — memory unavailable status visible via info-screen.
-        }
         throw err;
       }
     }
   }
 
+  /**
+   * Attempt to initialize the MemPalace backend. Returns true on success.
+   * Handles auto-install and one-way auto-migration of legacy memories.
+   * Never throws — any failure returns false so the SQLite fallback runs.
+   */
+  private tryInitMempalace(): boolean {
+    let install: MempalaceInstall | null;
+    try {
+      install = ensureMempalace();
+    } catch {
+      return false;
+    }
+    if (!install) return false;
+
+    // Sanity ping — if the palace/bridge is broken, fall back.
+    const ok = runBridge<string>(install, this.palacePath, "ping");
+    if (ok !== "pong") return false;
+
+    this.mempalaceInstall = install;
+    this.backend = "mempalace";
+
+    // One-way auto-migration of legacy memories (idempotent).
+    if (!isMigrated()) {
+      try {
+        runBridge(install, this.palacePath, "migrate", {
+          source_dir: getMemoryBaseDir(),
+        });
+        markMigrated();
+      } catch {
+        // Migration failed — palace still usable for new stores; legacy
+        // memories can be re-migrated later. Do not block.
+      }
+    }
+
+    return true;
+  }
+
   /**
    * Open database and set up schema. Called by init() with retry logic.
    */
@@ -341,6 +424,7 @@ export class MemoryStorage {
    * Check if database is healthy.
    */
   isHealthy(): boolean {
+    if (this.isMempalace()) return true;
     if (!this.db) return false;
     try {
       this.db.prepare("SELECT 1").get();
@@ -355,8 +439,6 @@ export class MemoryStorage {
    * Uses transaction to ensure atomicity — either all writes succeed or none do.
    */
   store(record: MemoryRecord): void {
-    if (!this.db) throw new Error("Storage not initialized");
-
     // Generate ID from title if not provided
     if (!record.id) {
       record.id = record.title.toLowerCase().replace(/[^a-z0-9]+/g, "_");
@@ -370,6 +452,13 @@ export class MemoryStorage {
     // Set project if not provided
     if (!record.project) record.project = this.projectName;
 
+    if (this.isMempalace()) {
+      this.storeMempalace(record);
+      return;
+    }
+
+    if (!this.db) throw new Error("Storage not initialized");
+
     // Prepare markdown content BEFORE transaction (fail fast)
     const mdPath = path.join(this.scopeDir, `${record.id}.md`);
     const frontmatter: MemoryFrontmatter = {
@@ -444,6 +533,37 @@ export class MemoryStorage {
     }
   }
 
+  /**
+   * Store a record via the MemPalace backend. Also writes the markdown
+   * tier so the human-readable file and legacy migration source stay
+   * consistent and durable as a fallback source.
+   */
+  private storeMempalace(record: MemoryRecord): void {
+    const install = this.mempalaceInstall!;
+    runBridge(install, this.palacePath, "store", {
+      record: {
+        id: record.id,
+        title: record.title,
+        content: record.content,
+        tags: record.tags,
+        project: record.project,
+        type: record.type,
+        created: record.created,
+        updated: record.updated,
+        source_kind: "markdown",
+      },
+    });
+    // Markdown tier (durable human copy + fallback source).
+    try {
+      const mdPath = path.join(this.scopeDir, `${record.id}.md`);
+      const dir = path.dirname(mdPath);
+      if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+      writeMemoryFile(mdPath, record);
+    } catch {
+      // Palace write succeeded; markdown is best-effort.
+    }
+  }
+
   /**
    * Sync orphaned markdown files into the database.
    * Reads all .md files in the project dir, parses frontmatter,
@@ -451,6 +571,15 @@ export class MemoryStorage {
    * Returns count of synced files.
    */
   syncOrphanedFiles(): number {
+    if (this.isMempalace()) {
+      const install = this.mempalaceInstall!;
+      const synced = runBridge<number>(install, this.palacePath, "sync_orphaned", {
+        project_dir: this.scopeDir,
+        wing: this.projectName,
+      });
+      return synced ?? 0;
+    }
+
     if (!this.db) throw new Error("Storage not initialized");
 
     const files = fs.readdirSync(this.scopeDir)
@@ -506,6 +635,13 @@ export class MemoryStorage {
    * Check if a memory with the given title already exists.
    */
   hasByTitle(title: string): boolean {
+    if (this.isMempalace()) {
+      const install = this.mempalaceInstall!;
+      return runBridge<boolean>(install, this.palacePath, "has_title", {
+        wing: this.projectName,
+        title,
+      }) ?? false;
+    }
     if (!this.db) throw new Error("Storage not initialized");
     const id = title.toLowerCase().replace(/[^a-z0-9]+/g, "_");
     const row = this.db.prepare("SELECT 1 FROM memories WHERE id = ?").get(id);
@@ -517,6 +653,14 @@ export class MemoryStorage {
    * Returns array of { record, similarity } sorted by similarity desc.
    */
   findSimilarByTitle(title: string, threshold = 0.6): Array<{ record: MemoryRecord; similarity: number }> {
+    if (this.isMempalace()) {
+      const install = this.mempalaceInstall!;
+      const rows = runBridge<Array<{ record: MempalaceRecord; similarity: number }>>(
+        install, this.palacePath, "find_similar",
+        { wing: this.projectName, title, threshold },
+      ) ?? [];
+      return rows.map((r) => ({ record: toMemoryRecord(r.record), similarity: r.similarity }));
+    }
     if (!this.db) throw new Error("Storage not initialized");
 
     const allRows = this.db.prepare("SELECT id, title FROM memories").all() as MemoryRow[];
@@ -549,6 +693,11 @@ export class MemoryStorage {
    * Get a memory record by ID.
    */
   getById(id: string): MemoryRecord | null {
+    if (this.isMempalace()) {
+      const install = this.mempalaceInstall!;
+      const rec = runBridge<MempalaceRecord | null>(install, this.palacePath, "get", { id });
+      return rec ? toMemoryRecord(rec) : null;
+    }
     if (!this.db) throw new Error("Storage not initialized");
 
     const row = this.db.prepare("SELECT * FROM memories WHERE id = ?").get(id) as MemoryRow | undefined;
@@ -571,6 +720,14 @@ export class MemoryStorage {
    * Get a memory record by title (fuzzy match).
    */
   getByTitle(title: string): MemoryRecord | null {
+    if (this.isMempalace()) {
+      const install = this.mempalaceInstall!;
+      const rec = runBridge<MempalaceRecord | null>(install, this.palacePath, "get_by_title", {
+        wing: this.projectName,
+        title,
+      });
+      return rec ? toMemoryRecord(rec) : null;
+    }
     if (!this.db) throw new Error("Storage not initialized");
 
     // Try exact match first
@@ -610,6 +767,13 @@ export class MemoryStorage {
    * List all memories (titles only).
    */
   listAll(): Array<{ id: string; title: string; type: string }> {
+    if (this.isMempalace()) {
+      const install = this.mempalaceInstall!;
+      const items = runBridge<MempalaceListItem[]>(install, this.palacePath, "list", {
+        wing: this.projectName,
+      }) ?? [];
+      return items;
+    }
     if (!this.db) throw new Error("Storage not initialized");
 
     const rows = this.db.prepare("SELECT id, title, type FROM memories ORDER BY updated DESC").all() as MemoryRow[];
@@ -620,6 +784,16 @@ export class MemoryStorage {
    * Delete a memory by ID.
    */
   delete(id: string): boolean {
+    if (this.isMempalace()) {
+      const install = this.mempalaceInstall!;
+      const ok = runBridge<boolean>(install, this.palacePath, "delete", { id }) ?? false;
+      // Also remove the markdown tier if present.
+      try {
+        const mdPath = path.join(this.scopeDir, `${id}.md`);
+        if (fs.existsSync(mdPath)) fs.unlinkSync(mdPath);
+      } catch { /* ignore */ }
+      return ok;
+    }
     if (!this.db) throw new Error("Storage not initialized");
 
     // Delete from vector table
@@ -658,6 +832,19 @@ export class MemoryStorage {
    * Search memories using hybrid approach.
    */
   search(query: string, limit = 10, embedding?: Float32Array | null): SearchResult[] {
+    if (this.isMempalace()) {
+      const install = this.mempalaceInstall!;
+      const rows = runBridge<MempalaceSearchResult[]>(install, this.palacePath, "search", {
+        query,
+        wing: this.projectName,
+        limit,
+      }) ?? [];
+      return rows.map((r) => ({
+        record: toMemoryRecord(r),
+        score: r.score,
+        snippet: r.snippet,
+      }));
+    }
     if (!this.db) throw new Error("Storage not initialized");
 
     const results: Map<string, SearchResult> = new Map();
@@ -801,6 +988,21 @@ export function searchAllProjects(
   query: string,
   limit = 10
 ): SearchResult[] {
+  // MemPalace global path: query across all wings in one call.
+  const install = ensureMempalace();
+  if (install) {
+    const rows = runBridge<MempalaceSearchResult[]>(install, DEFAULT_PALACE, "search", {
+      query,
+      limit,
+    }) ?? [];
+    return rows.map((r) => ({
+      record: toMemoryRecord(r),
+      score: r.score,
+      snippet: r.snippet,
+    }));
+  }
+
+  // SQLite fallback: iterate project directories.
   const projectDirs = getAllProjectDirs();
   const allResults: SearchResult[] = [];
 
@@ -835,6 +1037,19 @@ export function listAllProjects(): Array<{
   title: string;
   type: string;
 }> {
+  // MemPalace global path: list all drawers across wings.
+  const install = ensureMempalace();
+  if (install) {
+    const items = runBridge<MempalaceListItemAll[]>(install, DEFAULT_PALACE, "list_all", {}) ?? [];
+    return items.map((m) => ({
+      project: m.project,
+      id: m.id,
+      title: m.title,
+      type: m.type,
+    }));
+  }
+
+  // SQLite fallback: iterate project directories.
   const projectDirs = getAllProjectDirs();
   const allMemories: Array<{
     project: string;