agent-memory-git 0.1.0__py3-none-any.whl

agent_memory/ui_server.py

@@ -0,0 +1,371 @@
+"""The local server behind `mem ui`: the memory list, search, and edits.
+
+Listens on 127.0.0.1 only. The page gets a per-run token in its URL fragment
+and sends it on every API call; Host and Origin are checked too, so other
+pages in the browser cannot read or change memories.
+
+Every edit, addition or deletion is written to the data repository and
+committed on its own (only the file it touched), then pushed in the
+background like hook commits; Undo reverts that commit.
+"""
+
+import hashlib
+import json
+import secrets
+import subprocess
+import sys
+import threading
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
+from urllib.parse import parse_qs, urlparse
+
+import numpy as np
+
+from . import frontmatter, gitsync, store, ui
+from .context import detect, hostname
+from .util import SCOPES, TYPES, atomic_write, id_path, log_exc, new_id, now_iso, slugify
+
+STATIC = Path(__file__).with_name("webui")
+MIME = {".html": "text/html; charset=utf-8", ".css": "text/css; charset=utf-8",
+        ".js": "text/javascript; charset=utf-8"}
+CSP = ("default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; "
+       "connect-src 'self'; frame-ancestors 'none'; base-uri 'none'; form-action 'none'")
+PLACE_FIELDS = ("cwd", "git_root", "git_remote", "git_branch")
+SEARCH_HITS = 8
+
+
+class ApiError(Exception):
+    def __init__(self, status, message):
+        super().__init__(message)
+        self.status, self.message = status, message
+
+
+class UiApp:
+    def __init__(self, data_dir, semantic=True):
+        self.data = Path(data_dir)
+        self.mdir = store.memories_dir(data_dir)
+        self.semantic = semantic
+        self.lock = threading.Lock()
+        self.encoder = ui.QueryEncoder() if semantic else None
+        self.state, self.vectors, self.stamp_value = None, None, None
+        self.refresh()
+        if self.encoder and self.state.get("semantic"):  # load the model now, not on the first search
+            threading.Thread(target=self.encoder.encode, args=("warm up",), daemon=True).start()
+
+    # ------------------------------------------------------------ reads
+
+    def stamp(self):
+        head = gitsync.git(self.data, "rev-parse", "--short", "HEAD", timeout=5).stdout.strip()
+        newest, count = 0, 0
+        for path in self.mdir.rglob("*.md"):
+            count += 1
+            newest = max(newest, path.stat().st_mtime_ns)
+        return f"{head}:{count}:{newest}"
+
+    def refresh(self):
+        with self.lock:
+            out = []
+            state = ui.build(self.data, semantic=self.semantic, vectors_out=out)
+            self.state, self.vectors = state, (out[0] if out else None)
+            self.stamp_value = self.stamp()
+            self.state["stamp"] = self.stamp_value
+            self.state["sync"] = self.sync_status()
+
+    def current(self):
+        if self.stamp() != self.stamp_value:  # an agent or another editor changed the store
+            self.refresh()
+        return self.state
+
+    def sync_status(self):
+        if not gitsync.has_remote(self.data):
+            return {"remote": False}
+        r = gitsync.git(self.data, "rev-list", "--count", "@{u}..HEAD", timeout=5)
+        ahead = int(r.stdout.strip()) if r.returncode == 0 and r.stdout.strip().isdigit() else 0
+        return {"remote": True, "ahead": ahead}
+
+    def search(self, query):
+        """Memories closest in meaning to the query (the page does word matching itself)."""
+        query = (query or "").strip()
+        if not query or not self.semantic or self.vectors is None or not self.state["semantic"]:
+            return {"hits": [], "semantic": False}
+        vec = self.encoder.encode(query)
+        if vec is None:
+            return {"hits": [], "semantic": False}
+        scores = self.vectors @ vec
+        order = np.argsort(-scores)[:SEARCH_HITS]
+        ids = [self.state["memories"][int(i)]["id"] for i in order]
+        return {"hits": [{"id": mid, "s": round(float(scores[i]), 3)} for mid, i in zip(ids, order)],
+                "semantic": True}
+
+    # ------------------------------------------------------------ writes
+
+    def _find(self, mid):
+        m = store.find(self.data, str(mid or ""))
+        if not m or m["id"] != mid:
+            raise ApiError(404, "That memory no longer exists; it may have been deleted elsewhere.")
+        return m
+
+    def _load(self, mid, base):
+        path = self.mdir / self._find(mid)["rel"]
+        text = path.read_text("utf-8")
+        if base and hashlib.sha1(text.encode()).hexdigest()[:16] != base:
+            raise ApiError(409, "This memory changed on disk after you opened it (an agent may have "
+                                "edited it). Close it and open it again to see the new version.")
+        meta, body = frontmatter.split(text)
+        return path, meta, body
+
+    def _place_ctx(self, place):
+        if isinstance(place, dict) and place.get("path"):
+            path = Path(str(place["path"])).expanduser()
+            if not path.is_dir():
+                raise ApiError(400, f"{place['path']} is not a folder on this machine.")
+            return detect(str(path))
+        key = place.get("key") if isinstance(place, dict) else place
+        for p in self.state.get("places", []):
+            if p["key"] == key:
+                return dict(p["ctx"])
+        raise ApiError(400, "Pick a place from the list or type a folder path.")
+
+    def _commit(self, paths, message):
+        rels = [str(Path(p).relative_to(self.data)) for p in ([paths] if isinstance(paths, (str, Path)) else paths)]
+        gitsync.git(self.data, "add", "-A", "--", *rels)
+        r = gitsync.git(self.data, "-c", "commit.gpgsign=false", "commit", "-q", "--no-verify",
+                        "-m", message + "\n\nTool: ui", "--", *rels)
+        if r.returncode != 0:
+            if "nothing" in r.stdout + r.stderr:
+                return None
+            raise ApiError(500, f"git commit failed: {(r.stderr or r.stdout).strip()}")
+        head = gitsync.git(self.data, "rev-parse", "--short", "HEAD").stdout.strip()
+        if gitsync.has_remote(self.data):
+            gitsync.spawn_sync(self.data, push=True)
+        return head
+
+    def _write(self, fn):
+        lock = gitsync.Lock(self.data, timeout=10)
+        if not lock.__enter__():
+            raise ApiError(503, "The memory repository is busy (a hook is committing). Try again.")
+        try:
+            result = fn()
+        finally:
+            lock.__exit__()
+        self.refresh()
+        return result
+
+    def _apply(self, meta, body, change):
+        changed = []
+        for key, allowed in (("type", TYPES), ("scope", SCOPES)):
+            if key in change and change[key] != meta.get(key):
+                if change[key] not in allowed:
+                    raise ApiError(400, f"Unknown {key} {change[key]!r}.")
+                meta[key] = change[key]
+                changed.append(key)
+        if "description" in change:
+            desc = " ".join(str(change["description"]).split())
+            if not desc:
+                raise ApiError(400, "A memory needs a one-line description.")
+            if desc != meta.get("description"):
+                meta["description"] = desc
+                changed.append("description")
+        if "body" in change and str(change["body"]).rstrip() != body.rstrip():
+            body = str(change["body"])
+            changed.append("body")
+        source = dict(meta.get("source") or {})
+        if change.get("place") and meta.get("scope") == "here":
+            ctx = self._place_ctx(change["place"])
+            old = source.get("cwd")
+            for key in PLACE_FIELDS:
+                source.pop(key, None)
+            source.update({k: ctx[k] for k in PLACE_FIELDS if ctx.get(k)})
+            if old and old != source.get("cwd"):
+                source.setdefault("original_cwd", old)
+            changed.append("place")
+        if meta.get("scope") == "here" and not (source.get("cwd") or source.get("git_remote")):
+            raise ApiError(400, "Pick the place where this memory should load.")
+        if changed:
+            meta["updated"] = now_iso()
+        meta.pop("source", None)
+        if source:
+            meta["source"] = source  # provenance stays last, as the hooks write it
+        return body, changed
+
+    def create(self, p):
+        typ, scope = p.get("type"), p.get("scope")
+        if typ not in TYPES or scope not in SCOPES:
+            raise ApiError(400, "Pick a type and where the memory loads.")
+        desc = " ".join(str(p.get("description", "")).split())
+        if not desc:
+            raise ApiError(400, "A memory needs a one-line description.")
+        source = {"tool": "ui", "host": hostname()}
+        if scope == "here":
+            if not p.get("place"):
+                raise ApiError(400, "Pick the place where this memory should load.")
+            ctx = self._place_ctx(p["place"])
+            source.update({k: ctx[k] for k in PLACE_FIELDS if ctx.get(k)})
+        name = slugify(p.get("name") or desc)
+        mid = new_id(name)
+        meta = {"id": mid, "name": name, "type": typ, "scope": scope, "description": desc,
+                "created": now_iso(), "source": source}
+        path = self.mdir / id_path(mid)
+
+        def write():
+            atomic_write(path, frontmatter.join(meta, str(p.get("body", ""))))
+            return {"id": mid, "commit": self._commit(path, f"memory: add {mid} (ui)")}
+        return self._write(write)
+
+    def edit(self, p):
+        def write():
+            path, meta, body = self._load(p.get("id"), p.get("base"))
+            new_body, changed = self._apply(meta, body, p.get("change") or {})
+            if not changed:
+                return {"id": p.get("id"), "commit": None}
+            atomic_write(path, frontmatter.join(meta, new_body))
+            return {"id": p.get("id"),
+                    "commit": self._commit(path, f"memory: edit {p.get('id')} ({', '.join(changed)}) (ui)")}
+        return self._write(write)
+
+    def delete(self, p):
+        """Delete one memory ({id, base}) or several ({items: [{id, base}, ...]}) in one commit."""
+        items = p.get("items") if isinstance(p.get("items"), list) else [p]
+        if not items or len(items) > 200:
+            raise ApiError(400, "Nothing to delete.")
+
+        def write():
+            loaded = [self._load(it.get("id"), it.get("base")) for it in items]  # all or nothing
+            for path, _, _ in loaded:
+                path.unlink()
+            if len(loaded) == 1:
+                message = f"memory: delete {items[0].get('id')} (ui)\n\n{loaded[0][1].get('description', '')}"
+            else:
+                message = f"memory: delete {len(loaded)} memories (ui)\n\n" + "\n".join(
+                    f"- {it.get('id')}: {meta.get('description', '')}" for it, (_, meta, _) in zip(items, loaded))
+            return {"commit": self._commit([path for path, _, _ in loaded], message)}
+        return self._write(write)
+
+    def undo(self, p):
+        rev = str(p.get("commit") or "")
+        if not rev or len(rev) > 40 or any(c not in "0123456789abcdef" for c in rev):
+            raise ApiError(400, "Bad commit id.")
+        shown = gitsync.git(self.data, "show", "-s", "--format=%B", rev, timeout=10)
+        if shown.returncode != 0 or "Tool: ui" not in shown.stdout:
+            raise ApiError(400, "Only changes made on this page can be undone here.")
+
+        def write():
+            r = gitsync.git(self.data, "revert", "--no-commit", rev, timeout=20)
+            if r.returncode != 0:
+                gitsync.git(self.data, "revert", "--abort")
+                raise ApiError(409, "Could not undo: that memory changed again since. Edit it instead.")
+            gitsync.git(self.data, "-c", "commit.gpgsign=false", "commit", "-q", "--no-verify",
+                        "-m", f"memory: undo {rev} (ui)\n\nTool: ui", timeout=10)
+            if gitsync.has_remote(self.data):
+                gitsync.spawn_sync(self.data, push=True)
+            return {"ok": True}
+        return self._write(write)
+
+
+class Handler(BaseHTTPRequestHandler):
+    server_version = "agent-memory"
+    POSTS = {"/api/create": "create", "/api/edit": "edit", "/api/delete": "delete", "/api/undo": "undo"}
+
+    def log_message(self, *args):
+        pass
+
+    def _send(self, status, payload, ctype="application/json; charset=utf-8"):
+        body = payload if isinstance(payload, bytes) else json.dumps(payload, ensure_ascii=False).encode()
+        self.send_response(status)
+        for k, v in (("Content-Type", ctype), ("Content-Length", str(len(body))), ("Cache-Control", "no-store"),
+                     ("X-Content-Type-Options", "nosniff"), ("Referrer-Policy", "no-referrer")):
+            self.send_header(k, v)
+        if ctype.startswith("text/html"):
+            self.send_header("Content-Security-Policy", CSP)
+        self.end_headers()
+        self.wfile.write(body)
+
+    def _guard(self, api):
+        if self.headers.get("Host", "") not in self.server.hosts:
+            self._send(421, {"error": "wrong host"})
+            return False
+        origin = self.headers.get("Origin")
+        if origin and origin not in {f"http://{h}" for h in self.server.hosts}:
+            self._send(403, {"error": "cross-origin request refused"})
+            return False
+        if api and not secrets.compare_digest(self.headers.get("X-Mem-Token", ""), self.server.token):
+            self._send(401, {"error": "This link has expired. Run `mem ui` again and use the new link."})
+            return False
+        return True
+
+    def _run(self, fn):
+        try:
+            self._send(200, fn())
+        except ApiError as e:
+            self._send(e.status, {"error": e.message})
+        except Exception as e:
+            log_exc(self.server.app.data, f"ui {self.path}")
+            self._send(500, {"error": f"{type(e).__name__}: {e}"})
+
+    def do_GET(self):
+        url = urlparse(self.path)
+        api = url.path.startswith("/api/")
+        if not self._guard(api):
+            return
+        if not api:
+            name = "index.html" if url.path in ("/", "/index.html") else url.path.lstrip("/")
+            path = STATIC / name
+            if "/" in name or not path.is_file() or path.suffix not in MIME:
+                return self._send(404, {"error": "not found"})
+            return self._send(200, path.read_bytes(), MIME[path.suffix])
+        app, q = self.server.app, {k: v[0] for k, v in parse_qs(url.query).items()}
+        routes = {"/api/state": app.current, "/api/stamp": lambda: {"stamp": app.stamp()},
+                  "/api/search": lambda: app.search(q.get("q"))}
+        if url.path not in routes:
+            return self._send(404, {"error": "not found"})
+        self._run(routes[url.path])
+
+    def do_POST(self):
+        url = urlparse(self.path)
+        if not self._guard(True):
+            return
+        method = self.POSTS.get(url.path)
+        if not method:
+            return self._send(404, {"error": "not found"})
+        try:
+            length = int(self.headers.get("Content-Length") or 0)
+            payload = json.loads(self.rfile.read(length) or b"{}") if length else {}
+        except ValueError:
+            return self._send(400, {"error": "bad JSON"})
+        self._run(lambda: getattr(self.server.app, method)(payload))
+
+
+def make_server(data_dir, port=8790, semantic=True):
+    app = UiApp(data_dir, semantic=semantic)
+    try:
+        server = ThreadingHTTPServer(("127.0.0.1", port), Handler)
+    except OSError:
+        server = ThreadingHTTPServer(("127.0.0.1", 0), Handler)
+    port = server.server_address[1]
+    server.hosts = {f"127.0.0.1:{port}", f"localhost:{port}"}
+    server.token = secrets.token_urlsafe(18)
+    server.app = app
+    server.url = f"http://127.0.0.1:{port}/#t={server.token}"
+    return server
+
+
+def run(data_dir, port=8790, open_browser=True, semantic=True):
+    if semantic and not ui.model_ready():
+        print("No local embedding model; similar memories use keywords only. "
+              "Run `mem ui --fetch-model` (about 625 MB) to also search by meaning.", flush=True)
+    server = make_server(data_dir, port, semantic)
+    print(f"Memories: {server.url}", flush=True)
+    print("Keep this terminal open while you use it; Ctrl+C stops it.", flush=True)
+    if open_browser:
+        try:
+            subprocess.run(["open" if sys.platform == "darwin" else "xdg-open", server.url], check=False)
+        except OSError:
+            pass
+    try:
+        server.serve_forever()
+    except KeyboardInterrupt:
+        print("\nstopped")
+    finally:
+        server.server_close()
+        if server.app.encoder:
+            server.app.encoder.close()

agent_memory/util.py

@@ -0,0 +1,101 @@
+import datetime as _dt
+import os
+import re
+import secrets
+import tempfile
+import traceback
+from pathlib import Path
+
+HOME = Path.home()
+
+TYPES = ("user", "feedback", "project", "reference")
+SCOPES = ("global", "here")
+
+_B32 = "0123456789abcdefghjkmnpqrstvwxyz"
+
+
+def now():
+    return _dt.datetime.now().astimezone().replace(microsecond=0)
+
+
+def now_iso():
+    return now().isoformat()
+
+
+def parse_time(value):
+    """Best-effort ISO 8601 parse; returns an aware datetime or None."""
+    if not value:
+        return None
+    s = str(value).strip().replace("Z", "+00:00")
+    try:
+        t = _dt.datetime.fromisoformat(s)
+    except ValueError:
+        return None
+    return t if t.tzinfo else t.astimezone()
+
+
+def slugify(text, limit=40):
+    s = re.sub(r"[^a-z0-9]+", "-", str(text).lower()).strip("-")
+    s = s[:limit].rstrip("-")
+    return s or "note"
+
+
+def new_id(slug, when=None):
+    when = when or now()
+    suffix = "".join(_B32[b % 32] for b in secrets.token_bytes(4))
+    return f"{when:%Y%m%d}-{slugify(slug)}-{suffix}"
+
+
+def id_path(memory_id):
+    """Relative path of a memory inside the memories directory."""
+    return f"{memory_id[:4]}/{memory_id[4:6]}/{memory_id}.md"
+
+
+def is_under(child, parent):
+    try:
+        return os.path.commonpath([child, parent]) == parent and child != parent
+    except ValueError:
+        return False
+
+
+def specific(path):
+    """True if a folder is narrow enough to share memories with its relatives.
+
+    Home, the filesystem root and direct children of home (like ~/repos) are
+    too broad: matching on them would leak memories across unrelated work.
+    """
+    if not path:
+        return False
+    p = Path(path)
+    home = HOME
+    if p == home or p == Path(p.anchor):
+        return False
+    try:
+        return len(p.relative_to(home).parts) >= 2
+    except ValueError:
+        return len(p.parts) >= 4
+
+
+def atomic_write(path, text):
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    fd, tmp = tempfile.mkstemp(dir=path.parent, prefix=".tmp-")
+    with os.fdopen(fd, "w", encoding="utf-8") as f:
+        f.write(text)
+    os.replace(tmp, path)
+
+
+def log(data_dir, message):
+    try:
+        path = Path(data_dir) / ".cache" / "agent-memory.log"
+        path.parent.mkdir(parents=True, exist_ok=True)
+        if path.exists() and path.stat().st_size > 1_000_000:
+            path.replace(path.with_suffix(".log.1"))
+        with path.open("a", encoding="utf-8") as f:
+            f.write(f"{now_iso()} {message}\n")
+    except OSError:
+        pass
+
+
+def log_exc(data_dir, where):
+    log(data_dir, f"ERROR in {where}:\n{traceback.format_exc()}")

agent_memory/webui/app.css

@@ -0,0 +1,192 @@
+/* Memories: a search box, a row of filters, the list, and one memory at a time in the drawer. */
+:root {
+  color-scheme: light;
+  --page: #f7f7f5;
+  --surface: #ffffff;
+  --ink: #171716;
+  --ink-2: #57564f;
+  --ink-3: #8d8c85;
+  --line: #e6e5df;
+  --d1: #efeee9;
+  --accent: #2a78d6;
+  --accent-soft: rgba(42, 120, 214, 0.12);
+  --danger: #c93838;
+  --shadow: 0 12px 40px rgba(20, 20, 18, 0.14);
+  --mono: ui-monospace, SFMono-Regular, Menlo, monospace;
+  --t-user: #8a62cf; --t-feedback: #2a78d6; --t-project: #3c9a6b; --t-reference: #df8530;
+  --drawer: min(600px, 100vw);
+}
+@media (prefers-color-scheme: dark) {
+  :root {
+    color-scheme: dark;
+    --page: #121211;
+    --surface: #1b1b1a;
+    --ink: #f2f2ef;
+    --ink-2: #bcbbb3;
+    --ink-3: #85847d;
+    --line: #2b2b29;
+    --d1: #242422;
+    --accent: #4b93ea;
+    --accent-soft: rgba(75, 147, 234, 0.2);
+    --danger: #e66767;
+    --shadow: 0 12px 40px rgba(0, 0, 0, 0.6);
+    --t-user: #a98ae6; --t-feedback: #6aa1ec; --t-project: #5fbf8e; --t-reference: #f0a45c;
+  }
+}
+
+* { box-sizing: border-box; }
+[hidden] { display: none !important; }
+html, body { margin: 0; }
+body { background: var(--page); color: var(--ink); font: 14px/1.5 system-ui, -apple-system, "Segoe UI", "PingFang SC", sans-serif; }
+button, input, select, textarea { font: inherit; color: inherit; }
+button { cursor: pointer; }
+:focus-visible { outline: 2px solid var(--accent); outline-offset: 2px; }
+
+.btn { border: 1px solid var(--line); background: var(--surface); border-radius: 10px; padding: 7px 14px; font-size: 13px; display: inline-flex; align-items: center; gap: 6px; }
+.btn:hover { background: var(--d1); }
+.btn.primary { background: var(--ink); color: var(--surface); border-color: var(--ink); font-weight: 600; }
+.btn.primary:hover { opacity: .9; background: var(--ink); }
+.btn.danger { color: var(--danger); }
+.btn:disabled { opacity: .45; cursor: default; }
+.icon-btn { border: 0; background: none; width: 32px; height: 32px; border-radius: 8px; display: inline-grid; place-items: center; color: var(--ink-2); }
+.icon-btn:hover { background: var(--d1); color: var(--ink); }
+.icon-btn svg { width: 17px; height: 17px; fill: none; stroke: currentColor; stroke-width: 1.6; stroke-linecap: round; stroke-linejoin: round; }
+
+/* ---------- top: search, then filters */
+.top { position: sticky; top: 0; z-index: 10; background: color-mix(in srgb, var(--page) 92%, transparent); backdrop-filter: blur(6px); border-bottom: 1px solid var(--line); }
+.bar, .filters, .list { max-width: 1080px; margin: 0 auto; padding-left: 24px; padding-right: 24px; }
+.bar { display: flex; align-items: center; gap: 14px; padding-top: 14px; }
+.search { position: relative; flex: 1; }
+.search input { width: 100%; height: 42px; padding: 0 40px 0 40px; border-radius: 12px; border: 1px solid var(--line); background: var(--surface); outline: none; font-size: 15px; }
+.search input:focus { border-color: var(--accent); box-shadow: 0 0 0 3px var(--accent-soft); }
+.search input::-webkit-search-cancel-button { display: none; }
+.search-ico { position: absolute; left: 14px; top: 13px; width: 16px; height: 16px; fill: none; stroke: var(--ink-3); stroke-width: 1.6; stroke-linecap: round; }
+.search kbd { position: absolute; right: 12px; top: 11px; font: 11px var(--mono); color: var(--ink-3); border: 1px solid var(--line); border-radius: 5px; padding: 1px 6px; }
+.sync { font-size: 12px; color: var(--ink-3); white-space: nowrap; }
+
+.filters { display: flex; flex-wrap: wrap; align-items: center; gap: 6px; padding-top: 10px; padding-bottom: 10px; }
+.pill { position: relative; display: inline-flex; align-items: center; }
+.pill select { appearance: none; -webkit-appearance: none; border: 1px solid var(--line); background: var(--surface); border-radius: 999px; padding: 4px 26px 4px 11px; font-size: 13px; color: var(--ink-2); max-width: 230px; text-overflow: ellipsis; cursor: pointer; }
+.pill select:hover { border-color: var(--ink-3); }
+.pill::after { content: ""; position: absolute; right: 11px; top: 50%; width: 5px; height: 5px; border-right: 1.5px solid var(--ink-3); border-bottom: 1.5px solid var(--ink-3); transform: translateY(-70%) rotate(45deg); pointer-events: none; }
+.pill.on select { border-color: var(--ink); color: var(--ink); font-weight: 600; }
+.filters .clear { border: 0; background: none; color: var(--accent); font-size: 13px; padding: 4px 6px; }
+.filters .spacer { flex: 1; }
+.filters .count { font-size: 13px; color: var(--ink-3); font-variant-numeric: tabular-nums; }
+
+/* ---------- the list */
+.list { padding-top: 6px; padding-bottom: 120px; }
+.group { font-size: 12px; font-weight: 600; color: var(--ink-3); padding: 18px 10px 6px; letter-spacing: .02em; }
+.row { display: grid; grid-template-columns: 18px minmax(0, 1fr) auto; gap: 12px; align-items: start; padding: 10px 10px; border-radius: 10px; cursor: pointer; }
+.row + .row { border-top: 1px solid color-mix(in srgb, var(--line) 60%, transparent); }
+.row:hover { background: var(--surface); }
+.row.cursor { box-shadow: inset 0 0 0 1.5px var(--ink-3); }
+.row.open { background: var(--accent-soft); }
+.row.picked { background: var(--d1); }
+.row .chk { margin: 3px 0 0; opacity: 0; cursor: pointer; }
+.row:hover .chk, .row.picked .chk, .selecting .row .chk, .row.cursor .chk { opacity: 1; }
+.row .main { min-width: 0; }
+.row .desc { overflow-wrap: anywhere; display: -webkit-box; -webkit-line-clamp: 2; -webkit-box-orient: vertical; overflow: hidden; }
+.row .snip { font-size: 12.5px; color: var(--ink-3); margin-top: 2px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.row mark { background: color-mix(in srgb, var(--accent) 22%, transparent); color: inherit; border-radius: 3px; padding: 0 1px; }
+.kws { display: flex; flex-wrap: wrap; gap: 5px; margin-top: 5px; }
+.kw { border: 0; background: var(--d1); color: var(--ink-2); font-size: 11.5px; line-height: 18px; border-radius: 6px; padding: 0 7px; }
+.kw:hover { background: color-mix(in srgb, var(--accent) 16%, transparent); color: var(--ink); }
+.kw.on { background: var(--ink); color: var(--surface); }
+.d-head .kws { margin-top: 10px; }
+.d-head .kws + .chips { margin-top: 8px; }
+.issues { margin: 10px 0 0; padding: 7px 12px 7px 26px; border-radius: 8px; background: color-mix(in srgb, #d9822b 10%, transparent); color: var(--ink-2); font-size: 12.5px; }
+.issues li { margin: 1px 0; }
+.row .meta { display: flex; gap: 14px; font-size: 12px; color: var(--ink-3); white-space: nowrap; padding-top: 2px; }
+.row .meta .t { display: inline-flex; align-items: center; gap: 6px; width: 78px; }
+.row .meta .t i { width: 7px; height: 7px; border-radius: 50%; background: var(--ink-3); }
+.row .meta .t.user i { background: var(--t-user); } .row .meta .t.feedback i { background: var(--t-feedback); }
+.row .meta .t.project i { background: var(--t-project); } .row .meta .t.reference i { background: var(--t-reference); }
+.row .meta .p { width: 200px; overflow: hidden; text-overflow: ellipsis; }
+.row .meta .d { width: 84px; text-align: right; font-variant-numeric: tabular-nums; }
+.empty { text-align: center; color: var(--ink-3); padding: 70px 0; }
+.empty .btn { margin-top: 12px; }
+
+.selbar { position: fixed; left: 50%; bottom: 22px; transform: translateX(-50%); display: flex; gap: 8px; align-items: center; background: var(--ink); color: var(--surface); padding: 8px 8px 8px 16px; border-radius: 12px; box-shadow: var(--shadow); z-index: 20; }
+.selbar .n { font-weight: 600; margin-right: 6px; }
+.selbar .btn { background: transparent; color: var(--surface); border-color: color-mix(in srgb, var(--surface) 30%, transparent); }
+.selbar .btn:hover { background: color-mix(in srgb, var(--surface) 14%, transparent); }
+.selbar .btn.danger { background: var(--danger); border-color: var(--danger); color: #fff; }
+
+/* with the drawer open on a wide window, the list moves over to stay readable */
+@media (min-width: 1300px) {
+  body.drawer-open .bar, body.drawer-open .filters, body.drawer-open .list { margin-left: max(0px, calc((100vw - var(--drawer) - 1080px) / 2)); margin-right: var(--drawer); }
+  body.drawer-open .selbar { left: calc((100vw - var(--drawer)) / 2); }
+}
+
+/* ---------- drawer: one memory, everything in its file */
+.drawer { position: fixed; top: 0; right: 0; bottom: 0; width: min(600px, 100vw); background: var(--surface); border-left: 1px solid var(--line); box-shadow: var(--shadow); transform: translateX(104%); transition: transform .22s ease; z-index: 30; display: flex; flex-direction: column; }
+.drawer.open { transform: none; }
+.d-head { padding: 18px 20px 14px; border-bottom: 1px solid var(--line); }
+.d-bar { display: flex; align-items: center; gap: 4px; margin: -6px -8px 8px 0; }
+.d-bar .where { flex: 1; font-size: 12px; color: var(--ink-3); overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.d-head h1 { font-size: 18px; line-height: 1.4; margin: 0; font-weight: 650; overflow-wrap: anywhere; }
+.chips { display: flex; flex-wrap: wrap; gap: 6px; margin-top: 10px; }
+.chip { font-size: 12px; color: var(--ink-2); background: var(--d1); border-radius: 6px; padding: 2px 8px; }
+.tabs { display: flex; gap: 2px; margin-top: 14px; }
+.tabs button { border: 0; background: none; padding: 5px 10px; border-radius: 7px; font-size: 13px; color: var(--ink-3); }
+.tabs button[aria-selected="true"] { background: var(--d1); color: var(--ink); font-weight: 600; }
+.d-body { flex: 1; overflow-y: auto; padding: 18px 20px 40px; }
+.props { display: grid; grid-template-columns: max-content minmax(0, 1fr); gap: 5px 16px; font-size: 12.5px; margin: 0 0 20px; padding: 12px 14px; background: var(--page); border-radius: 10px; }
+.props dt { color: var(--ink-3); white-space: nowrap; }
+.props dt.sub { padding-left: 12px; }
+.props dd { margin: 0; color: var(--ink-2); overflow-wrap: anywhere; font-family: var(--mono); font-size: 12px; }
+.props .group { grid-column: 1 / -1; color: var(--ink-3); font-size: 11px; margin-top: 4px; }
+pre.raw { white-space: pre-wrap; overflow-wrap: anywhere; font: 12.5px/1.6 var(--mono); background: var(--page); border-radius: 10px; padding: 14px; margin: 0; }
+.similar { margin-top: 28px; }
+.similar h2 { font-size: 12px; color: var(--ink-3); font-weight: 600; margin: 0 0 6px; letter-spacing: .02em; }
+.similar button { display: flex; gap: 10px; width: 100%; text-align: left; border: 0; background: none; padding: 7px 8px; border-radius: 8px; align-items: baseline; }
+.similar button:hover { background: var(--d1); }
+.similar .t { flex: 1; overflow-wrap: anywhere; }
+.similar .p { font-size: 12px; color: var(--ink-3); font-variant-numeric: tabular-nums; }
+
+/* rendered markdown */
+.md { font-size: 14.5px; line-height: 1.65; overflow-wrap: anywhere; }
+.md > :first-child { margin-top: 0; }
+.md h1, .md h2, .md h3, .md h4 { line-height: 1.35; margin: 1.3em 0 .5em; }
+.md h1 { font-size: 17px; } .md h2 { font-size: 15.5px; } .md h3, .md h4 { font-size: 14.5px; }
+.md p { margin: .6em 0; }
+.md ul, .md ol { padding-left: 1.4em; margin: .5em 0; }
+.md li { margin: .2em 0; }
+.md code { font: 12.5px var(--mono); background: var(--d1); padding: 1px 5px; border-radius: 5px; }
+.md pre { background: var(--page); border-radius: 10px; padding: 12px 14px; overflow-x: auto; }
+.md pre code { background: none; padding: 0; white-space: pre; }
+.md blockquote { margin: .6em 0; padding: 2px 14px; border-left: 3px solid var(--line); color: var(--ink-2); }
+.md table { border-collapse: collapse; font-size: 13px; margin: .8em 0; display: block; overflow-x: auto; }
+.md th, .md td { border: 1px solid var(--line); padding: 5px 9px; text-align: left; vertical-align: top; }
+.md hr { border: 0; border-top: 1px solid var(--line); margin: 1.2em 0; }
+.md a { color: var(--accent); }
+.md .wikilink { color: var(--accent); cursor: pointer; text-decoration: underline; text-underline-offset: 2px; }
+
+/* editor */
+.form { display: grid; gap: 16px; }
+.form label { display: grid; gap: 6px; font-size: 12px; color: var(--ink-3); font-weight: 600; }
+.form input[type="text"], .form textarea, .form select { border: 1px solid var(--line); background: var(--surface); border-radius: 10px; padding: 9px 11px; font-weight: 400; color: var(--ink); font-size: 14px; }
+.form textarea.desc { font-size: 15px; font-weight: 500; resize: vertical; min-height: 48px; }
+.form textarea.body { font: 13px/1.6 var(--mono); min-height: 320px; resize: vertical; }
+.form .row { display: grid; grid-template-columns: 1fr 1fr; gap: 12px; }
+.seg { display: inline-flex; border: 1px solid var(--line); border-radius: 10px; padding: 2px; gap: 2px; }
+.seg button { border: 0; background: none; padding: 6px 12px; border-radius: 8px; font-size: 13px; color: var(--ink-2); font-weight: 400; }
+.seg button[aria-pressed="true"] { background: var(--d1); color: var(--ink); font-weight: 600; }
+.form .hint { font-weight: 400; color: var(--ink-3); }
+.form .hint.over { color: var(--danger); }
+.d-foot { padding: 12px 20px; border-top: 1px solid var(--line); display: flex; gap: 8px; justify-content: flex-end; align-items: center; }
+.d-foot .err { flex: 1; color: var(--danger); font-size: 13px; }
+
+.toasts { position: fixed; left: 50%; bottom: 24px; transform: translateX(-50%); display: grid; gap: 8px; z-index: 40; }
+.toast { background: var(--ink); color: var(--surface); border-radius: 10px; padding: 10px 14px; font-size: 13px; display: flex; align-items: center; gap: 16px; box-shadow: var(--shadow); }
+.toast.error { background: var(--danger); color: #fff; }
+.toast button { border: 0; background: none; color: inherit; font-weight: 700; padding: 0; text-decoration: underline; text-underline-offset: 2px; }
+.boot { position: fixed; inset: 0; display: grid; place-items: center; background: var(--page); color: var(--ink-3); z-index: 50; text-align: center; padding: 24px; }
+
+@media (max-width: 900px) { .row .meta .p { display: none; } }
+@media (max-width: 760px) {
+  .bar, .filters, .list { padding-left: 12px; padding-right: 12px; }
+  .search kbd { display: none; }
+  .row .meta .t { display: none; }
+}