Explorar también las memorias de los proyectos

Claude Code deja, además de las sesiones, un directorio memory/ por proyecto:
un .md por recuerdo con frontmatter, y un MEMORY.md que hace de índice. Lo
que no figura en ese índice sigue en disco pero deja de cargarse en contexto,
así que la diferencia entre ambos es justamente lo que vale la pena mirar.

-m cambia de sesiones a memorias y reusa los mismos verbos:

  claude-sesiones -m                  tabla de memorias
  claude-sesiones -m docker           busca en nombre, descripción y cuerpo
  claude-sesiones -m -s 3             lee la nº 3 (o -s <nombre>)
  claude-sesiones -m --check          audita índices, enlaces y orígenes
  claude-sesiones -m -D 3             la borra y la saca de MEMORY.md
  claude-sesiones -m --type feedback  filtra por tipo declarado

--check es la parte con criterio propio: reporta memorias que no están en
MEMORY.md, entradas del índice que apuntan a archivos que ya no existen,
enlaces [[...]] rotos y sesiones de origen que ya no están.

El registro de una memoria usa claves cortas como el de sesiones, por el
mismo motivo: viaja embebido en el HTML, que ahora tiene su propia pestaña
de memorias.

Claude-Session: https://claude.ai/code/session_01RmtZ9qBemrc9TncwVTG6ED

5 files changed, 966 insertions, 48 deletions

diff --git a/claude_sesiones/cli.py b/claude_sesiones/cli.py
index 90fb51b..4dc5ab2 100644
--- a/claude_sesiones/cli.py
+++ b/claude_sesiones/cli.py
@@ -14,9 +14,10 @@ from .sessions import (
     load_sessions, pick, public_records, session_path,
 )
 from .terminal import (
-    Style, clip, fmt_date, fmt_size, plural, print_chat, print_table,
-    resume_cmd,
+    Style, clip, fmt_date, fmt_size, plural, print_audit, print_chat,
+    print_memories, print_memory, print_table, resume_cmd,
 )
+from . import memory as mem
 from . import webpage
 
 DEFAULT_HTML = "sesiones.html"
@@ -46,6 +47,15 @@ borrado (irreversible; pregunta antes, salvo con -y):
   claude-sesiones --delete-empty             borra las vacías
   claude-sesiones -D 101 -D e0a4300e         borra sesiones puntuales
   claude-sesiones -p /tmp --delete-empty     solo las vacías de ese proyecto
+
+memoria de los proyectos (-m cambia de sesiones a memorias y reusa los mismos
+verbos: filtro, -s para leer, -D para borrar):
+  claude-sesiones -m                  tabla de memorias
+  claude-sesiones -m docker           busca en nombre, descripción y cuerpo
+  claude-sesiones -m -s 3             lee la memoria nº 3
+  claude-sesiones -m -s deadlock      lo mismo, por nombre
+  claude-sesiones -m --check          audita índices, enlaces y orígenes
+  claude-sesiones -m -D 3             la borra y la saca de MEMORY.md
 """
 
 
@@ -75,6 +85,14 @@ def build_parser():
                     help="no usa $PAGER para el chat")
     ap.add_argument("--no-color", action="store_true", help="salida sin color")
 
+    recuerdos = ap.add_argument_group("memoria de los proyectos")
+    recuerdos.add_argument("-m", "--memory", action="store_true",
+                           help="trabaja sobre las memorias en vez de las sesiones")
+    recuerdos.add_argument("--type", metavar="TIPO", choices=mem.TYPES,
+                           help="filtra por tipo: " + " | ".join(mem.TYPES))
+    recuerdos.add_argument("--check", action="store_true",
+                           help="audita índices, enlaces y sesiones de origen")
+
     salida = ap.add_argument_group("exportar")
     salida.add_argument("--json", action="store_true",
                         help="vuelca todas las sesiones en JSON")
@@ -214,19 +232,23 @@ def delete_targets(pool, args):
 
 def cmd_json(sessions):
     import json
-    json.dump(public_records(sessions), sys.stdout,
-              ensure_ascii=False, separators=(",", ":"))
+    payload = webpage.build_payload(
+        public_records(sessions),
+        mem.public_records(mem.load_memories(sessions)))
+    json.dump(payload, sys.stdout, ensure_ascii=False, separators=(",", ":"))
     sys.stdout.write("\n")
     return 0
 
 
 def cmd_html(sessions, args):
     out = args.html
-    stats = webpage.write(public_records(sessions), out,
+    memories = mem.public_records(mem.load_memories(sessions))
+    stats = webpage.write(public_records(sessions), out, memories=memories,
                           template=webpage.template_text(args.template))
     print(f"{stats['sesiones']} sesiones · {stats['proyectos']} proyectos · "
           f"{stats['mensajes']} mensajes · {stats['bloques']} bloques "
-          f"de transcripción → {out}", file=sys.stderr)
+          f"de transcripción · {stats['memorias']} memorias → {out}",
+          file=sys.stderr)
     if args.open:
         webbrowser.open("file://" + os.path.abspath(out))
     return 0
@@ -263,6 +285,124 @@ def cmd_table(sessions, args, st):
     return 0
 
 
+def mem_filtered(memories, args):
+    return mem.apply_filters(memories, project=args.project,
+                             query=" ".join(args.query) or None,
+                             kind=args.type)
+
+
+def cmd_mem_show(memories, args, st):
+    m = mem.pick(mem_filtered(memories, args), args.show)
+    buf = io.StringIO()
+    print_memory(m, st, buf, path=mem.memory_path(m))
+    text = buf.getvalue()
+    if args.no_pager:
+        sys.stdout.write(text)
+    else:
+        from .terminal import pager
+        pager(text)
+    return 0
+
+
+def cmd_mem_check(memories, sessions, st):
+    report = mem.audit(memories, sessions)
+    total = print_audit(report, st, sys.stdout)
+    if total:
+        print(f"{st.faint}{plural(total, 'cosa para mirar', 'cosas para mirar')} "
+              f"en {plural(len(memories), 'memoria', 'memorias')}.{st.reset}")
+        return 1
+    print(f"{st.amber}Todo en orden: "
+          f"{plural(len(memories), 'memoria', 'memorias')}, "
+          f"índices y enlaces consistentes.{st.reset}")
+    return 0
+
+
+def delete_memories(targets, args, st):
+    if not targets:
+        print("No hay memorias que borrar con ese criterio.", file=sys.stderr)
+        return 0
+
+    print(f"{st.bold}Se van a borrar "
+          f"{plural(len(targets), 'memoria', 'memorias')}:{st.reset}\n")
+    total_kb = 0
+    for m in targets:
+        total_kb += m["k"]
+        print(f"  {st.ink}{clip(m['name'], 38):<38}{st.reset} "
+              f"{clip(m['ty'], 9):<9} "
+              f"{st.grey}{clip(m['p'], 34):<34}{st.reset} "
+              f"{st.faint}{fmt_size(m['k']):>9}{st.reset}")
+        if m["desc"]:
+            print(f"    {st.faint}{clip(m['desc'], 86)}{st.reset}")
+
+    print(f"\n{st.faint}{fmt_size(total_kb)} en total · "
+          f"también se quita su línea de MEMORY.md{st.reset}")
+
+    if args.dry_run:
+        print(f"\n{st.faint}--dry-run: no se tocó nada.{st.reset}")
+        return 0
+
+    if not args.yes:
+        print(f"\n{st.copper}Esto no se puede deshacer.{st.reset}")
+        if not confirm("¿Confirmás? [s/N] "):
+            print("Cancelado.", file=sys.stderr)
+            return 1
+
+    done = failed = unlisted = 0
+    for m in targets:
+        try:
+            if mem.delete(m):
+                unlisted += 1
+            done += 1
+        except OSError as e:
+            print(f"error: {m['name']}: {e}", file=sys.stderr)
+            failed += 1
+
+    extra = f", {unlisted} sacadas del índice" if unlisted else ""
+    print(f"\n{plural(done, 'memoria borrada', 'memorias borradas')}{extra}.")
+    return 1 if failed else 0
+
+
+def cmd_mem_table(memories, args, st, total):
+    if not memories:
+        print("Ninguna memoria coincide con ese filtro.", file=sys.stderr)
+        return 1
+    shown = memories[: args.limit] if args.limit else memories
+
+    print_memories(shown, st, latest_activity(shown), sys.stdout)
+
+    projects = len({m["p"] for m in memories})
+    tail = (f"{len(shown)} de {total} memorias" if len(shown) != total
+            else f"{plural(total, 'memoria', 'memorias')} · "
+                 f"{plural(projects, 'proyecto', 'proyectos')}")
+    print(f"\n{st.faint}{tail} · -m -s <nº> para leer una{st.reset}")
+    return 0
+
+
+def run_memory(sessions, args, st):
+    memories = mem.load_memories(sessions)
+    if not memories:
+        print("Ningún proyecto tiene memorias todavía.", file=sys.stderr)
+        return 1
+
+    if args.check:
+        return cmd_mem_check(memories, sessions, st)
+
+    if args.delete:
+        pool = mem_filtered(memories, args)
+        targets, seen = [], set()
+        for ref in args.delete:
+            m = mem.pick(pool, ref)
+            if m["name"] not in seen:
+                seen.add(m["name"])
+                targets.append(m)
+        return delete_memories(targets, args, st)
+
+    if args.show:
+        return cmd_mem_show(memories, args, st)
+
+    return cmd_mem_table(mem_filtered(memories, args), args, st, len(memories))
+
+
 def run(args):
     root = default_root()
     if not os.path.isdir(root):
@@ -275,13 +415,16 @@ def run(args):
         print("No hay ninguna sesión registrada todavía.", file=sys.stderr)
         return 1
 
+    st = Style.from_stream(sys.stdout, args.no_color)
+
+    if args.memory:
+        return run_memory(sessions, args, st)
+
     if args.json:
         return cmd_json(sessions)
     if args.html:
         return cmd_html(sessions, args)
 
-    st = Style.from_stream(sys.stdout, args.no_color)
-
     if args.delete or args.delete_empty:
         targets = delete_targets(filtered(sessions, args), args)
         return delete_sessions(targets, args, st)
diff --git a/claude_sesiones/memory.py b/claude_sesiones/memory.py
new file mode 100644
index 0000000..ccb2e65
--- /dev/null
+++ b/claude_sesiones/memory.py
@@ -0,0 +1,272 @@
+"""Memorias de proyecto: los .md que Claude Code deja en <proyecto>/memory/.
+
+Cada proyecto puede acumular recuerdos en
+
+    ~/.claude/projects/<proyecto>/memory/<nombre>.md
+
+Un archivo por recuerdo, con frontmatter YAML (`name`, `description`,
+`metadata.type`, `metadata.originSessionId`) y cuerpo markdown. Al lado vive
+`MEMORY.md`, el índice: una línea por memoria, y es lo único que se carga en
+contexto al arrancar una sesión. Una memoria que no figura ahí sigue en disco
+pero deja de recordarse, así que la diferencia entre ambos vale la pena mirarla.
+
+Esquema del registro que devuelve `read_memory`, con las mismas claves cortas
+que `sessions` porque también viaja embebido en el HTML:
+
+    name  nombre del frontmatter (o el del archivo si falta)
+    file  nombre del archivo, con extensión
+    p     cwd del proyecto
+    desc  descripción del frontmatter
+    ty    tipo declarado: project | user | feedback | reference
+    src   uuid de la sesión que la creó, si lo declara
+    body  cuerpo markdown, sin el frontmatter
+    ln    enlaces [[...]] que aparecen en el cuerpo
+    k     tamaño en KB
+    l     mtime del archivo (ISO 8601)
+    ix    True si figura en MEMORY.md
+    hix   True si el proyecto tiene MEMORY.md
+
+`project_dir` es interno y `public_records()` lo saca antes de serializar.
+"""
+
+import glob
+import os
+import re
+from datetime import datetime, timezone
+
+from .sessions import SessionError, default_root
+
+INDEX_NAME = "MEMORY.md"
+
+INTERNAL_KEYS = ("project_dir",)
+
+TYPES = ("project", "user", "feedback", "reference")
+
+FRONTMATTER_RE = re.compile(r"^---\s*\n(.*?)\n---\s*\n?", re.S)
+LINK_RE = re.compile(r"\[\[([^\]\n]+)\]\]")
+# En el índice cada línea es "- [Título](archivo.md) — pista".
+INDEX_LINK_RE = re.compile(r"\(([^)\n]+)\.md\)")
+
+
+def memory_dir(project_dir, root=None):
+    return os.path.join(root or default_root(), project_dir, "memory")
+
+
+def memory_path(m, root=None):
+    return os.path.join(memory_dir(m["project_dir"], root), m["file"])
+
+
+def index_path(project_dir, root=None):
+    return os.path.join(memory_dir(project_dir, root), INDEX_NAME)
+
+
+# ──────────────────────────────── parseo ────────────────────────────────
+
+def _field(front, key):
+    """Valor de una clave del frontmatter. Plano: alcanza para lo que escribe
+    Claude Code, que anida `type` y `originSessionId` pero sin repetirlas."""
+    hit = re.search(r"^\s*%s:\s*(.+?)\s*$" % re.escape(key), front, re.M)
+    if not hit:
+        return None
+    value = hit.group(1).strip()
+    # YAML de una línea: si viene entrecomillado, las comillas internas están
+    # escapadas y hay que devolverlas como estaban.
+    for quote in ('"', "'"):
+        if len(value) >= 2 and value[0] == quote and value[-1] == quote:
+            value = value[1:-1]
+            if quote == '"':
+                value = value.replace('\\"', '"').replace("\\\\", "\\")
+            break
+    return value or None
+
+
+def read_memory(path, project_dir):
+    with open(path, "r", encoding="utf-8", errors="ignore") as f:
+        raw = f.read()
+
+    match = FRONTMATTER_RE.match(raw)
+    front, body = (match.group(1), raw[match.end():]) if match else ("", raw)
+    stat = os.stat(path)
+    filename = os.path.basename(path)
+
+    return {
+        "name": _field(front, "name") or filename[:-3],
+        "file": filename,
+        "project_dir": project_dir,
+        "desc": _field(front, "description") or "",
+        "ty": _field(front, "type") or "—",
+        "src": _field(front, "originSessionId"),
+        "body": body.strip(),
+        "ln": sorted(set(LINK_RE.findall(body))),
+        "k": round(stat.st_size / 1024, 1),
+        "l": datetime.fromtimestamp(stat.st_mtime, tz=timezone.utc).isoformat(),
+    }
+
+
+def read_index(project_dir, root=None):
+    """Nombres (sin .md) que el MEMORY.md del proyecto enlaza."""
+    try:
+        with open(index_path(project_dir, root), "r",
+                  encoding="utf-8", errors="ignore") as f:
+            return set(INDEX_LINK_RE.findall(f.read()))
+    except OSError:
+        return set()
+
+
+# ──────────────────────────────── carga ────────────────────────────────
+
+def load_memories(sessions, root=None):
+    """Lee las memorias de todos los proyectos.
+
+    La ruta real del proyecto sale de las sesiones: el nombre del directorio
+    codifica "/" y "." los dos como "-" y no se puede invertir.
+    """
+    root = root or default_root()
+    cwd_by_dir = {}
+    for s in sessions:
+        cwd_by_dir.setdefault(s.get("project_dir"), s.get("p"))
+
+    memories = []
+    for d in sorted(glob.glob(os.path.join(root, "*", "memory"))):
+        project_dir = os.path.basename(os.path.dirname(d))
+        files = sorted(f for f in glob.glob(os.path.join(d, "*.md"))
+                       if os.path.basename(f) != INDEX_NAME)
+        if not files:
+            continue  # un memory/ vacío no es un proyecto con memoria
+
+        has_index = os.path.exists(os.path.join(d, INDEX_NAME))
+        listed = read_index(project_dir, root) if has_index else set()
+
+        for path in files:
+            try:
+                m = read_memory(path, project_dir)
+            except OSError:
+                continue
+            m["p"] = cwd_by_dir.get(project_dir) or project_dir
+            m["hix"] = has_index
+            m["ix"] = m["file"][:-3] in listed
+            memories.append(m)
+
+    memories.sort(key=lambda m: m["l"], reverse=True)
+    return memories
+
+
+def public_records(memories):
+    """Copia sin las claves internas, lista para serializar."""
+    out = []
+    for m in memories:
+        clean = dict(m)
+        for key in INTERNAL_KEYS:
+            clean.pop(key, None)
+        out.append(clean)
+    return out
+
+
+# ──────────────────────────────── filtros ────────────────────────────────
+
+def apply_filters(memories, project=None, query=None, kind=None):
+    out = memories
+
+    if project:
+        needle = os.path.expanduser(project).rstrip("/").lower()
+        out = [m for m in out if needle in m["p"].lower()]
+
+    if kind:
+        out = [m for m in out if m["ty"].lower() == kind.lower()]
+
+    if query:
+        needle = query.lower()
+        out = [m for m in out
+               if needle in m["name"].lower()
+               or needle in m["desc"].lower()
+               or needle in m["p"].lower()
+               or needle in m["body"].lower()]
+
+    return out
+
+
+def pick(memories, ref):
+    """Resuelve un índice de la tabla (1-based) o un prefijo del nombre."""
+    if ref.isdigit():
+        i = int(ref)
+        if 1 <= i <= len(memories):
+            return memories[i - 1]
+        raise SessionError(
+            f"el índice {i} está fuera de rango (hay {len(memories)} memorias)")
+
+    needle = ref.lower()
+    hits = [m for m in memories if m["name"].lower().startswith(needle)]
+    if not hits:
+        hits = [m for m in memories if needle in m["name"].lower()]
+    if len(hits) == 1:
+        return hits[0]
+    if not hits:
+        raise SessionError(f"ninguna memoria coincide con '{ref}'")
+    nombres = ", ".join(m["name"] for m in hits[:4])
+    raise SessionError(
+        f"'{ref}' es ambiguo, coincide con {len(hits)}: {nombres}"
+        + (", …" if len(hits) > 4 else ""))
+
+
+# ──────────────────────────────── auditoría ────────────────────────────────
+
+def audit(memories, sessions, root=None):
+    """Inconsistencias entre archivos, índices, enlaces y sesiones de origen."""
+    known = {m["name"] for m in memories} | {m["file"][:-3] for m in memories}
+    session_ids = {s["id"] for s in sessions}
+
+    report = {
+        "sin_indice": [m for m in memories if not m["hix"]],
+        "sin_listar": [m for m in memories if m["hix"] and not m["ix"]],
+        "enlaces_rotos": [(m, link) for m in memories
+                          for link in m["ln"] if link not in known],
+        "origen_perdido": [m for m in memories
+                           if m["src"] and m["src"] not in session_ids],
+        "indice_fantasma": [],
+    }
+
+    for project_dir in sorted({m["project_dir"] for m in memories if m["hix"]}):
+        real = {m["file"][:-3] for m in memories
+                if m["project_dir"] == project_dir}
+        for missing in sorted(read_index(project_dir, root) - real):
+            report["indice_fantasma"].append((project_dir, missing))
+
+    return report
+
+
+def audit_total(report):
+    return sum(len(v) for v in report.values())
+
+
+# ──────────────────────────────── borrado ────────────────────────────────
+
+def unindex(m, root=None):
+    """Saca del MEMORY.md la línea que apunta a esta memoria.
+
+    Devuelve True si el índice cambió. No es un error que no cambie: la memoria
+    podía no estar listada.
+    """
+    path = index_path(m["project_dir"], root)
+    try:
+        with open(path, "r", encoding="utf-8", errors="ignore") as f:
+            lines = f.readlines()
+    except OSError:
+        return False
+
+    needle = "(%s)" % m["file"]
+    kept = [ln for ln in lines if needle not in ln]
+    if len(kept) == len(lines):
+        return False
+
+    try:
+        with open(path, "w", encoding="utf-8") as f:
+            f.writelines(kept)
+    except OSError:
+        return False
+    return True
+
+
+def delete(m, root=None):
+    """Borra el archivo y lo saca del índice. Devuelve si se desindexó."""
+    os.remove(memory_path(m, root))
+    return unindex(m, root)
diff --git a/claude_sesiones/template.html b/claude_sesiones/template.html
index 279749c..e56cc30 100644
--- a/claude_sesiones/template.html
+++ b/claude_sesiones/template.html
@@ -570,6 +570,153 @@
     .reader { width: 100%; border-left: 0; }
   }
 
+  /* ---------- pestañas y memorias ---------- */
+
+  .tabs {
+    display: flex;
+    gap: 2px;
+    margin-bottom: 18px;
+    border-bottom: 1px solid var(--line);
+  }
+  .tab {
+    font: inherit;
+    font-size: 13.5px;
+    color: var(--muted);
+    background: none;
+    border: 0;
+    border-bottom: 2px solid transparent;
+    padding: 8px 14px;
+    margin-bottom: -1px;
+    cursor: pointer;
+    display: inline-flex;
+    align-items: center;
+    gap: 7px;
+  }
+  .tab:hover { color: var(--ink); }
+  .tab[aria-selected="true"] { color: var(--amber); border-bottom-color: var(--amber); }
+  .tab .n {
+    font-family: var(--mono);
+    font-size: 11px;
+    font-variant-numeric: tabular-nums;
+    color: var(--faint);
+    background: var(--raised);
+    border: 1px solid var(--line);
+    border-radius: 10px;
+    padding: 0 6px;
+  }
+  .tab[aria-selected="true"] .n { color: var(--amber); border-color: var(--amber-lo); background: var(--amber-bg); }
+
+  body[data-mode="s"] .only-m,
+  body[data-mode="m"] .only-s { display: none; }
+
+  .row.mem { grid-template-columns: 3px 1fr 104px 210px 108px; }
+
+  .mem-name { display: flex; align-items: baseline; gap: 7px; flex-wrap: wrap; }
+  .mem-name .nm { font-size: 14px; color: var(--ink); font-family: var(--mono); }
+  .mem-desc {
+    margin: 3px 0 0;
+    font-size: 12.5px;
+    line-height: 1.45;
+    color: var(--muted);
+    display: -webkit-box;
+    -webkit-line-clamp: 2;
+    -webkit-box-orient: vertical;
+    overflow: hidden;
+  }
+
+  .ty {
+    font-family: var(--mono);
+    font-size: 10.5px;
+    letter-spacing: .05em;
+    padding: 1px 6px;
+    border-radius: 3px;
+    border: 1px solid var(--line);
+    color: var(--muted);
+    white-space: nowrap;
+  }
+  .ty-project   { color: var(--amber); border-color: var(--amber-lo); background: var(--amber-bg); }
+  .ty-user      { color: var(--focus); border-color: var(--focus); background: transparent; }
+  .ty-feedback  { color: var(--copper, var(--amber)); border-color: var(--amber-lo); }
+  .ty-reference { color: var(--muted); }
+
+  /* Una memoria fuera de MEMORY.md sigue en disco pero no se carga en contexto. */
+  .chip-unlisted { color: var(--amber); border-color: var(--amber-lo); background: var(--amber-bg); }
+
+  .mem-body {
+    font-size: 14.5px;
+    line-height: 1.68;
+    color: var(--ink-soft);
+    white-space: pre-wrap;
+    overflow-wrap: anywhere;
+  }
+  .mem-body pre {
+    margin: 10px 0;
+    padding: 10px 12px;
+    background: var(--surface);
+    border: 1px solid var(--line);
+    border-radius: 6px;
+    overflow-x: auto;
+    font-family: var(--mono);
+    font-size: 12.5px;
+    white-space: pre;
+    color: var(--ink);
+  }
+  .mem-body code {
+    font-family: var(--mono);
+    font-size: .87em;
+    background: var(--surface);
+    border: 1px solid var(--line-soft);
+    border-radius: 4px;
+    padding: 1px 4px;
+  }
+  .mem-body pre code { background: none; border: 0; padding: 0; font-size: inherit; }
+  .mem-body strong { color: var(--ink); font-weight: 600; }
+  .mem-body .h { display: block; margin: 10px 0 -2px; font-weight: 620; color: var(--ink); }
+
+  .wl {
+    font-family: var(--mono);
+    font-size: .9em;
+    color: var(--amber);
+    background: var(--amber-bg);
+    border: 1px solid var(--amber-lo);
+    border-radius: 4px;
+    padding: 0 4px;
+    cursor: pointer;
+  }
+  .wl.dead { color: var(--faint); border-color: var(--line); background: none; cursor: default; }
+
+  .mem-foot {
+    margin-top: 22px;
+    padding-top: 14px;
+    border-top: 1px solid var(--line);
+    display: flex;
+    flex-direction: column;
+    gap: 8px;
+    font-family: var(--mono);
+    font-size: 11.5px;
+    color: var(--muted);
+  }
+  .mem-foot .lbl { color: var(--faint); margin-right: 6px; }
+
+  .jump {
+    align-self: flex-start;
+    font-family: var(--mono);
+    font-size: 11.5px;
+    color: var(--muted);
+    background: var(--raised);
+    border: 1px solid var(--line);
+    border-radius: 6px;
+    padding: 6px 10px;
+    cursor: pointer;
+  }
+  .jump:hover { color: var(--amber); border-color: var(--amber-lo); background: var(--amber-bg); }
+
+  @media (max-width: 860px) {
+    .row.mem { grid-template-columns: 3px 1fr auto; }
+    .row.mem .cell-ty { grid-column: 2; padding-bottom: 10px; }
+    .row.mem .cell-proj { display: none; }
+  }
+
   @media (prefers-reduced-motion: reduce) {
     * { transition: none !important; }
   }
@@ -590,6 +737,15 @@
     <code>&lt;script id="payload"&gt;</code>.</p>
   </noscript>
 
+  <div class="tabs" role="tablist" aria-label="Qué mirar">
+    <button type="button" class="tab" role="tab" data-mode="s" aria-selected="true">
+      Sesiones <span class="n" id="nS"></span>
+    </button>
+    <button type="button" class="tab" role="tab" data-mode="m" aria-selected="false">
+      Memorias <span class="n" id="nM"></span>
+    </button>
+  </div>
+
   <div class="stats" id="stats"></div>
 
   <div class="toolbar">
@@ -598,8 +754,10 @@
       <input type="search" id="q" placeholder="buscar título, ruta o uuid…  (/)" autocomplete="off" spellcheck="false" aria-label="Buscar sesiones">
     </div>
     <select id="proj" aria-label="Filtrar por proyecto"></select>
-    <label class="toggle"><input type="checkbox" id="deep"> buscar dentro del chat</label>
-    <label class="toggle"><input type="checkbox" id="hideEmpty"> ocultar vacías</label>
+    <label class="toggle only-s"><input type="checkbox" id="deep"> buscar dentro del chat</label>
+    <label class="toggle only-s"><input type="checkbox" id="hideEmpty"> ocultar vacías</label>
+    <select id="mtype" class="only-m" aria-label="Filtrar por tipo de memoria"></select>
+    <label class="toggle only-m"><input type="checkbox" id="unlisted"> solo fuera del índice</label>
     <button type="button" class="tbtn" id="theme" title="Cambiar entre claro y oscuro" aria-label="Cambiar tema">
       <svg class="moon" width="14" height="14" viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.4"><path d="M13.5 9.6A5.8 5.8 0 0 1 6.4 2.5a5.8 5.8 0 1 0 7.1 7.1Z"/></svg>
       <svg class="sun" width="14" height="14" viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.4"><circle cx="8" cy="8" r="3.1"/><path d="M8 1v1.6M8 13.4V15M1 8h1.6M13.4 8H15M3.1 3.1l1.1 1.1M11.8 11.8l1.1 1.1M12.9 3.1l-1.1 1.1M4.2 11.8l-1.1 1.1"/></svg>
@@ -607,7 +765,7 @@
   </div>
 
   <div class="grid" role="table" aria-label="Sesiones de Claude Code">
-    <div class="row head" role="row">
+    <div class="row head only-s" role="row">
       <span></span>
       <button type="button" data-sort="t" class="pad-l">Sesión <span class="car">▾</span></button>
       <button type="button" data-sort="l">Fecha <span class="car">▾</span></button>
@@ -615,12 +773,19 @@
       <button type="button" data-sort="d" class="num">Dur. <span class="car">▾</span></button>
       <span class="pad-r" style="text-align:right">Reanudar</span>
     </div>
+    <div class="row head mem only-m" role="row">
+      <span></span>
+      <button type="button" data-msort="name" class="pad-l">Memoria <span class="car">▾</span></button>
+      <button type="button" data-msort="ty">Tipo <span class="car">▾</span></button>
+      <button type="button" data-msort="p">Proyecto <span class="car">▾</span></button>
+      <button type="button" data-msort="l">Fecha <span class="car">▾</span></button>
+    </div>
     <div id="rows"></div>
   </div>
 
   <p class="count" id="count"></p>
 
-  <div class="legend">
+  <div class="legend only-s">
     <span>Franja izquierda = antigüedad:</span>
     <span><i style="background:var(--amber)"></i>hoy / ayer</span>
     <span><i style="background:var(--amber);opacity:.55"></i>última semana</span>
@@ -628,7 +793,16 @@
     <span><i style="background:var(--line)"></i>más viejo</span>
   </div>
 
-  <div class="foot">
+  <div class="legend only-m">
+    <span><span class="chip chip-unlisted">fuera del índice</span> = está en disco pero no figura en MEMORY.md, así que no se carga en contexto</span>
+  </div>
+
+  <div class="foot only-m">
+    <p>Cada proyecto guarda sus recuerdos en <code>&lt;proyecto&gt;/memory/</code>: un <code>.md</code> por memoria y un <code>MEMORY.md</code> que los indexa. El índice es lo único que se lee al arrancar una sesión.</p>
+    <p>Los tipos los define Claude al escribirlas: <b>project</b> es trabajo en curso, <b>user</b> quién sos y cómo trabajás, <b>feedback</b> correcciones tuyas, <b>reference</b> punteros a recursos externos.</p>
+  </div>
+
+  <div class="foot only-s">
     <p>Los títulos los genera Claude durante la sesión. Cuando falta, cae al primer mensaje tuyo — y ahí se nota, porque arranca en minúscula o suena a pregunta suelta.</p>
     <p><b>Vacía</b> es una sesión que se abrió pero nunca recibió un mensaje: un <code>/resume</code> cancelado, un <code>/login</code>. <b>No interactiva</b> es un <code>claude -p</code> con algo piped por stdin — típicamente un <code>git diff</code> para redactar el mensaje de commit, no un chat.</p>
     <p>La transcripción trae el texto de la conversación y una línea por herramienta usada, pero no lo que esas herramientas devolvieron: son el 95 % del volumen en disco.</p>
@@ -660,18 +834,30 @@
 
 <script id="payload" type="application/json">__DATA__</script>
 <script>
-const DATA = JSON.parse(document.getElementById('payload').textContent);
+const PAYLOAD = JSON.parse(document.getElementById('payload').textContent);
+const DATA = PAYLOAD.s || [];
+const MEM = PAYLOAD.m || [];
 // Instantánea = la actividad más reciente de los datos, para que "hoy" siga siendo
 // cierto respecto de cuándo se leyeron los logs y no del reloj de quien mira.
-const NOW = new Date(Math.max(...DATA.map(d => +new Date(d.l))));
+const NOW = new Date(Math.max(
+  ...DATA.map(d => +new Date(d.l)), ...MEM.map(m => +new Date(m.l))));
 const BY_ID = new Map(DATA.map(d => [d.id, d]));
+const BY_NAME = new Map(MEM.map(m => [m.name, m]));
+// Los enlaces [[...]] pueden apuntar al nombre declarado o al del archivo.
+MEM.forEach(m => { const f = m.file.replace(/\.md$/, ''); if (!BY_NAME.has(f)) BY_NAME.set(f, m); });
 
 const $ = s => document.querySelector(s);
 const rowsEl = $('#rows'), qEl = $('#q'), projEl = $('#proj'), deepEl = $('#deep'),
       emptyEl = $('#hideEmpty'), countEl = $('#count'), toastEl = $('#toast'),
-      readerEl = $('#reader'), scrimEl = $('#scrim'), bodyEl = $('#rBody');
+      readerEl = $('#reader'), scrimEl = $('#scrim'), bodyEl = $('#rBody'),
+      typeEl = $('#mtype'), unlistedEl = $('#unlisted');
 
-let sortKey = 'l', sortDir = -1, openId = null, lastFocus = null;
+let sortKey = 'l', sortDir = -1, lastFocus = null;
+let mSortKey = 'l', mSortDir = -1;
+// Qué hay abierto en el lector: {kind: 's'|'m', key} o null.
+let open_ = null;
+// Sin memorias la pestaña no aporta nada, así que arrancamos siempre en sesiones.
+let mode = 's';
 
 /* ---------- formato ---------- */
 
@@ -723,7 +909,7 @@ function mark(text, q) {
 // Markdown mínimo: código, negritas y títulos. Los saltos los resuelve pre-wrap.
 // El código se guarda aparte antes de tocar negritas, para que un ** dentro de
 // un bloque de código quede tal cual.
-function renderBody(text) {
+function renderBody(text, wikilinks) {
   const stash = [];
   // Tras esc() no queda ningún "<" crudo en el texto: todos son &lt;. Por eso un
   // marcador con "<" no puede colisionar con el contenido del mensaje.
@@ -735,6 +921,16 @@ function renderBody(text) {
   out = out.replace(/`([^`\n]+)`/g, (_, code) => keep(`<code>${code}</code>`));
   out = out.replace(/^#{1,6}\s+(.+)$/gm, '<b class="h">$1</b>');
   out = out.replace(/\*\*([^*\n]+)\*\*/g, '<strong>$1</strong>');
+  if (wikilinks) {
+    // Va acá adentro, con el código ya guardado aparte: un [[...]] dentro de un
+    // bloque de código tiene que quedar como texto.
+    out = out.replace(/\[\[([^\]\n]+)\]\]/g, (_, name) => {
+      const hit = BY_NAME.get(name);
+      return hit
+        ? `<button type="button" class="wl" data-wl="${esc(hit.name)}">${esc(name)}</button>`
+        : `<span class="wl dead" title="todavía no existe una memoria con ese nombre">${esc(name)}</span>`;
+    });
+  }
 
   return out.replace(/<K(\d+)>/g, (_, i) => stash[i]);
 }
@@ -752,17 +948,31 @@ function renderBody(text) {
     ['tus mensajes', msgs, ''],
     ['en disco', mb.toFixed(1), ' MB'],
     ['período', `${pad(f.getDate())} ${MES[f.getMonth()]} – ${pad(l.getDate())} ${MES[l.getMonth()]}`, ''],
+    ['memorias', MEM.length, ''],
   ].map(([k, v, s]) => `<div class="stat"><span class="stat-k">${k}</span><span class="stat-v">${v}${s ? `<small>${s}</small>` : ''}</span></div>`).join('');
 })();
 
-(function projects() {
+function fillProjects() {
+  const src = mode === 'm' ? MEM : DATA;
   const counts = {};
-  DATA.forEach(d => counts[d.p] = (counts[d.p] || 0) + 1);
-  projEl.innerHTML = `<option value="">todos los proyectos (${DATA.length})</option>` +
+  src.forEach(d => counts[d.p] = (counts[d.p] || 0) + 1);
+  const label = mode === 'm' ? 'memorias' : 'sesiones';
+  projEl.innerHTML = `<option value="">todos los proyectos (${src.length} ${label})</option>` +
     Object.entries(counts).sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))
       .map(([p, n]) => `<option value="${esc(p)}">${esc(p)} · ${n}</option>`).join('');
+}
+
+(function types() {
+  const counts = {};
+  MEM.forEach(m => counts[m.ty] = (counts[m.ty] || 0) + 1);
+  typeEl.innerHTML = `<option value="">todos los tipos (${MEM.length})</option>` +
+    Object.entries(counts).sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))
+      .map(([t, n]) => `<option value="${esc(t)}">${esc(t)} · ${n}</option>`).join('');
 })();
 
+$('#nS').textContent = DATA.length;
+$('#nM').textContent = MEM.length;
+
 /* ---------- lista ---------- */
 
 function convoText(d) {
@@ -808,7 +1018,7 @@ function current() {
   return list;
 }
 
-function render() {
+function renderSessions() {
   const list = current();
   const q = qEl.value.trim();
   const ql = q.toLowerCase();
@@ -854,15 +1064,99 @@ function render() {
     : `${list.length} de ${DATA.length} sesiones`;
 }
 
+/* ---------- memorias ---------- */
+
+function currentMem() {
+  const q = qEl.value.trim().toLowerCase();
+  const proj = projEl.value, ty = typeEl.value;
+
+  const list = MEM.filter(m => {
+    if (proj && m.p !== proj) return false;
+    if (ty && m.ty !== ty) return false;
+    if (unlistedEl.checked && m.ix) return false;
+    if (!q) return true;
+    return m.name.toLowerCase().includes(q)
+        || m.desc.toLowerCase().includes(q)
+        || m.p.toLowerCase().includes(q)
+        || m.body.toLowerCase().includes(q);
+  });
+
+  list.sort((a, b) => {
+    const k = mSortKey;
+    if (k === 'l') return (new Date(a.l) - new Date(b.l)) * mSortDir;
+    const av = String(a[k]).toLowerCase(), bv = String(b[k]).toLowerCase();
+    return av < bv ? -mSortDir : av > bv ? mSortDir : 0;
+  });
+  return list;
+}
+
+function renderMem() {
+  const list = currentMem();
+  const q = qEl.value.trim();
+
+  if (!list.length) {
+    rowsEl.innerHTML = `<div class="none">Ninguna memoria coincide con ese filtro.</div>`;
+    countEl.textContent = '';
+    return;
+  }
+
+  rowsEl.innerHTML = list.map(m => `
+