Add feed-memex command: live MCP memory via memex-mvp integration

End-to-end verified: ran on real data, 16 sessions feed memex's inbox
chokidar watcher, all 1381 dialogue messages indexed in SQLite + FTS5,
memex_search returns hits from Cowork sessions immediately. Search hit:
'SberBusiness' → cowork-77f2b3f4 transcript. The most-automated workflow
described in the strategy deck slide 11 is now real.

WHAT IT DOES
`claude-backup feed-memex` finds every Code + Cowork session, parses
each via our existing parser (real-format-aware, dialogue-only filter,
thinking-signature stripping), and writes a clean JSONL to
~/.memex/inbox/ in the FLAT shape memex's claude-code parser expects:

  {"role":"user","content":"...","timestamp":"...","id":"..."}
  {"role":"assistant","content":"...","timestamp":"...","id":"..."}

Filename convention:
  code-<8-char-id>.jsonl    — Claude Code sessions
  cowork-<8-char-id>.jsonl  — Claude Cowork sessions

Memex picks them up via chokidar within seconds, indexes via SQLite+FTS5,
and exposes them to any MCP-compatible AI agent (Cursor, Cline, Claude
Code, Continue, Zed) through memex_search/memex_recent/memex_get_conversation.

WHY JSONL NOT MARKDOWN
Investigated both. Markdown would require a new parser in memex AND lose
structured timestamps + role + id fields (would need regex from heading
markers, fragile). Memex's existing claude-code parser already reads flat
top-level role/content/timestamp — feeding clean JSONL composes cleanly
with zero patches in memex (cowork-prefix support is a tiny bonus patch).

WHY NOT JUST SYMLINK RAW JSONL
Memex's existing claude-code parser was written against the original spec
(top-level role/content). Real Claude Code uses nested message.role/content,
which memex's parser silently drops as 'no text'. Symlinking raw JSONL
would feed memex an empty index. Pre-processing in claude-backup uses our
real-format-aware parser, applies dialogue_text() to filter tool_use /
thinking / signatures, then emits flat-format JSONL memex can index.

DESIGN CHOICES IN SERVICE OF AUTOMATION
- Stable msg ids (sha1 of role+timestamp+content[:200]) so re-runs of
  feed-memex don't duplicate (memex's UNIQUE(source, conversation_id,
  msg_id) constraint handles the rest).
- Dialogue-only filter: tool_use / tool_result / thinking blocks all
  stripped, plus role gating (user/assistant only — drops legacy flat
  tool_result messages with string content that previously slipped
  through is_dialogue_message).
- Two-source aware: scanner already discovers both Code and Cowork; the
  prefix in filename ('code-' vs 'cowork-') lets memex tag source
  correctly when running with the cowork-prefix patch.

CODE
- cli.py: feed_memex_cmd, _to_memex_record helper, DEFAULT_MEMEX_INBOX
  constant; --dry-run and --inbox flags.
- 8 new tests covering: file creation, prefix conventions for both
  sources, JSONL record shape (matches memex parser expectations),
  noise stripping (tool_use, thinking, signatures), msg id stability
  across runs, dry-run behaviour, missing-memex error path.

114/114 tests pass.

DOCS
README + README.ru gain a new 'Live MCP memory' subsection under the
handoff section, explaining the Cursor-agent workflow and the
filename convention.

Author: sedelev

README.md

@@ -223,6 +223,19 @@ Workflow:
 
 A 200-message session typically packs into 80–200 KB of text — fine for context windows of any modern hosted assistant.
 
+### Live MCP memory — `feed-memex`
+
+If you run [memex-mvp](https://github.com/parallelclaw/memex-mvp) (a separate local MCP server), `claude-backup feed-memex` writes a clean dialogue-only JSONL of every session into memex's inbox folder (`~/.memex/inbox/`). Memex picks them up via `chokidar`, indexes via SQLite + FTS5, and exposes them through MCP to **any compatible AI agent** — Cursor, Cline, Claude Code, Continue, Zed.
+
+```bash
+claude-backup feed-memex            # write all sessions to ~/.memex/inbox/
+claude-backup feed-memex --dry-run  # show what would be written
+```
+
+Output is idempotent — re-run anytime, memex dedupes by stable msg_id. Once set up, your Cursor agent can just `memex_search("the migration we discussed in April")` and surface real results from your past Code/Cowork conversations. **Zero paste.** Zero context-switching.
+
+Filename convention: `code-<8char>.jsonl` for Claude Code sessions, `cowork-<8char>.jsonl` for Cowork. Memex distinguishes the two via the prefix and tags them with separate `source` values, so you can filter `memex_search` by source.
+
 ### Rescue bundle (`rescue`) — the banned-user escape hatch
 
 `handoff` is for one session. `rescue` is for **all of them at once** — built specifically for the situation where Anthropic suspends your account and you need to keep working. Your local files survive (Anthropic only revokes API access, not your disk), so you can package the lot and hand it to a different AI provider.

README.ru.md

@@ -223,6 +223,19 @@ Workflow:
 
 Сессия из 200 сообщений обычно укладывается в 80–200 КБ текста — нормально для context window любого современного хостед-ассистента.
 
+### Живая MCP-память — `feed-memex`
+
+Если у вас установлен [memex-mvp](https://github.com/parallelclaw/memex-mvp) (отдельный локальный MCP-сервер), команда `claude-backup feed-memex` пишет clean dialogue-only JSONL каждой сессии в memex'овский inbox (`~/.memex/inbox/`). Memex подхватывает через `chokidar`, индексирует в SQLite + FTS5, и даёт доступ через MCP **любому совместимому AI-агенту** — Cursor, Cline, Claude Code, Continue, Zed.
+
+```bash
+claude-backup feed-memex            # записать все сессии в ~/.memex/inbox/
+claude-backup feed-memex --dry-run  # показать что будет записано
+```
+
+Вывод идемпотентный — запускайте сколько угодно, memex дедуплицирует по стабильным msg_id. После настройки ваш Cursor-агент может вызвать `memex_search("миграция о которой мы говорили в апреле")` и получить реальные результаты из прошлых Code/Cowork разговоров. **Никакой пасты.** Никаких переключений контекста.
+
+Конвенция имён: `code-<8char>.jsonl` для Claude Code сессий, `cowork-<8char>.jsonl` для Cowork. Memex различает их по префиксу и помечает разными `source`-значениями — можно фильтровать `memex_search` по источнику.
+
 ### Rescue-пакет (`rescue`) — escape hatch для забаненного юзера
 
 `handoff` это для одной сессии. `rescue` — это для **всех сразу**, специально под ситуацию когда Anthropic заблокировал аккаунт и нужно продолжать работать. Локальные файлы переживают бан (Anthropic блокирует только API-доступ, не диск), так что можно упаковать всё и отдать другому AI-провайдеру.

claude_backup/cli.py

@@ -2,6 +2,8 @@
 
 from __future__ import annotations
 
+import hashlib
+import json
 import sys
 from pathlib import Path
 
@@ -16,7 +18,7 @@
     render_rescue_index,
     render_rescue_readme,
 )
-from .parser import parse_session
+from .parser import dialogue_text, is_dialogue_message, parse_session
 from .scanner import (
     ProjectInfo,
     SOURCE_CODE,
@@ -320,6 +322,118 @@ def rescue_cmd(ctx: click.Context, output: Path | None, lang: str) -> None:
     )
 
 
+DEFAULT_MEMEX_INBOX = Path.home() / ".memex" / "inbox"
+
+
+@main.command(
+    "feed-memex",
+    help=(
+        "Write clean dialogue-only JSONL exports of every session to "
+        "memex's inbox folder (default ~/.memex/inbox/). Memex (a local "
+        "MCP server, see github.com/parallelclaw/memex-mvp) will index "
+        "them via FTS5 and expose them to any MCP-compatible AI agent "
+        "(Cursor, Cline, Claude Code, Continue, Zed) for live querying."
+    ),
+)
+@click.option(
+    "--inbox",
+    type=click.Path(path_type=Path),
+    default=DEFAULT_MEMEX_INBOX,
+    show_default=True,
+    help="Memex inbox path.",
+)
+@click.option(
+    "--dry-run",
+    is_flag=True,
+    default=False,
+    help="Show what would be written without writing.",
+)
+@click.pass_context
+def feed_memex_cmd(ctx: click.Context, inbox: Path, dry_run: bool) -> None:
+    if not inbox.parent.exists() and not dry_run:
+        click.echo(
+            f"Memex install not found at {inbox.parent}. Install it first:\n"
+            "  https://github.com/parallelclaw/memex-mvp",
+            err=True,
+        )
+        sys.exit(1)
+    if not dry_run:
+        inbox.mkdir(parents=True, exist_ok=True)
+
+    projects = _safe_scan(ctx.obj.get("claude_home"), ctx.obj.get("cowork_home"))
+    written = 0
+    skipped = 0
+    total_msgs = 0
+
+    for project in projects:
+        for session in project.sessions:
+            if session.jsonl_path is None or not session.jsonl_path.exists():
+                continue
+
+            short_id = session.session_id[:8]
+            prefix = "cowork" if session.source == SOURCE_COWORK else "code"
+            target = inbox / f"{prefix}-{short_id}.jsonl"
+
+            messages = parse_session(session.jsonl_path)
+            dialogue = [
+                m
+                for m in messages
+                if m.role in ("user", "assistant") and is_dialogue_message(m)
+            ]
+            if not dialogue:
+                skipped += 1
+                continue
+
+            lines = [
+                _to_memex_record(m, session.session_id, prefix)
+                for m in dialogue
+            ]
+
+            if dry_run:
+                click.echo(
+                    f"would write: {target.name}  ({len(lines)} msgs · "
+                    f"{session.title or session.first_prompt or '(untitled)'})"
+                )
+            else:
+                with target.open("w", encoding="utf-8") as f:
+                    for line in lines:
+                        f.write(json.dumps(line, ensure_ascii=False) + "\n")
+                written += 1
+                total_msgs += len(lines)
+
+    if dry_run:
+        click.echo(f"\nDry run. Would write {written} files; skipped {skipped} empty.")
+        return
+
+    click.echo(
+        f"\n✅ Fed memex: {written} files, {total_msgs} dialogue messages."
+        f"\n   inbox: {inbox}"
+        f"\n   memex (if running) will pick them up via chokidar within seconds."
+        f"\n   Re-run anytime — output is idempotent (memex dedupes by msg_id)."
+    )
+
+
+def _to_memex_record(msg, session_id: str, prefix: str) -> dict:
+    """Serialize a Message into the flat shape memex's claude-code parser expects.
+
+    Memex looks at top-level `role`, `content` (string), `timestamp`, `id`.
+    We use a stable hash for `id` so re-feeding deduplicates via memex's
+    UNIQUE constraint on (source, conversation_id, msg_id).
+    """
+    text = dialogue_text(msg)
+    msg_id_seed = f"{msg.role}|{msg.timestamp}|{text[:200]}"
+    msg_id = hashlib.sha1(msg_id_seed.encode("utf-8")).hexdigest()[:16]
+    record = {
+        "role": msg.role,
+        "content": text,
+        "timestamp": msg.timestamp,
+        "id": f"{prefix}-{session_id[:8]}-{msg_id}",
+    }
+    if msg.model:
+        record["model"] = msg.model
+    return record
+
+
 def _project_subdir(project: ProjectInfo) -> Path:
     """Pick the directory name for a project under <output>/<source>/.
 

tests/test_feed_memex.py

@@ -0,0 +1,222 @@
+"""Tests for the `feed-memex` command — writes clean JSONL to memex's inbox.
+
+Memex is a separate local MCP server (github.com/parallelclaw/memex-mvp).
+This command produces dialogue-only JSONL files in memex's inbox folder
+in the flat format memex's existing claude-code parser expects:
+
+    {"role":"user","content":"...","timestamp":"...","id":"..."}
+    {"role":"assistant","content":"...","timestamp":"...","id":"..."}
+
+Each session becomes one .jsonl file named `code-<short>.jsonl` or
+`cowork-<short>.jsonl`. The prefix lets memex distinguish sources.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from click.testing import CliRunner
+
+from claude_backup.cli import main
+
+
+def test_feed_memex_creates_jsonl_per_session(
+    claude_home: Path, tmp_path: Path
+) -> None:
+    runner = CliRunner()
+    inbox = tmp_path / "memex" / "inbox"
+    inbox.parent.mkdir(parents=True, exist_ok=True)
+    result = runner.invoke(
+        main,
+        [
+            "--claude-home",
+            str(claude_home),
+            "feed-memex",
+            "--inbox",
+            str(inbox),
+        ],
+    )
+    assert result.exit_code == 0, result.output
+    assert inbox.is_dir()
+    files = list(inbox.glob("*.jsonl"))
+    assert len(files) >= 1
+
+
+def test_feed_memex_uses_code_prefix_for_code_sessions(
+    claude_home: Path, tmp_path: Path
+) -> None:
+    runner = CliRunner()
+    inbox = tmp_path / "memex" / "inbox"
+    inbox.parent.mkdir(parents=True, exist_ok=True)
+    result = runner.invoke(
+        main,
+        [
+            "--claude-home",
+            str(claude_home),
+            "feed-memex",
+            "--inbox",
+            str(inbox),
+        ],
+    )
+    assert result.exit_code == 0, result.output
+    code_files = list(inbox.glob("code-*.jsonl"))
+    assert len(code_files) >= 1, "expected at least one code-*.jsonl file"
+
+
+def test_feed_memex_uses_cowork_prefix_for_cowork_sessions(
+    claude_home: Path, tmp_path: Path
+) -> None:
+    """Test fixture has Cowork sessions in fixtures-cowork/. Once it's in the
+    cowork-home, the feed-memex command should produce cowork-* files."""
+    cowork_root = Path(__file__).parent / "fixtures-cowork"
+    runner = CliRunner()
+    inbox = tmp_path / "memex" / "inbox"
+    inbox.parent.mkdir(parents=True, exist_ok=True)
+    result = runner.invoke(
+        main,
+        [
+            "--claude-home",
+            str(claude_home),
+            "--cowork-home",
+            str(cowork_root),
+            "feed-memex",
+            "--inbox",
+            str(inbox),
+        ],
+    )
+    assert result.exit_code == 0, result.output
+    cowork_files = list(inbox.glob("cowork-*.jsonl"))
+    assert len(cowork_files) >= 1, "expected at least one cowork-*.jsonl file"
+
+
+def test_feed_memex_record_shape_matches_memex_parser(
+    claude_home: Path, tmp_path: Path
+) -> None:
+    """Each line must have top-level `role` + `content` (string) + `timestamp`
+    + `id`. That's what memex's claude-code parser reads (server.js:215-263)."""
+    runner = CliRunner()
+    inbox = tmp_path / "inbox"
+    inbox.mkdir()
+    runner.invoke(
+        main,
+        [
+            "--claude-home",
+            str(claude_home),
+            "feed-memex",
+            "--inbox",
+            str(inbox),
+        ],
+    )
+    files = list(inbox.glob("code-*.jsonl"))
+    assert files, "no code-* files written"
+
+    with files[0].open("r", encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            rec = json.loads(line)
+            assert "role" in rec and isinstance(rec["role"], str)
+            assert "content" in rec and isinstance(rec["content"], str)
+            assert rec["content"].strip(), "empty content should not be written"
+            assert "id" in rec
+            # timestamp may be empty string if missing in source
+            assert "timestamp" in rec
+
+
+def test_feed_memex_strips_tool_use_and_thinking(
+    claude_home: Path, tmp_path: Path
+) -> None:
+    """Ensures the output is dialogue-only — no tool_use, tool_result, or
+    thinking signature noise pollutes the memex index."""
+    runner = CliRunner()
+    inbox = tmp_path / "inbox"
+    inbox.mkdir()
+    runner.invoke(
+        main,
+        [
+            "--claude-home",
+            str(claude_home),
+            "feed-memex",
+            "--inbox",
+            str(inbox),
+        ],
+    )
+    for f in inbox.glob("*.jsonl"):
+        content = f.read_text(encoding="utf-8")
+        assert "[tool_use:" not in content
+        assert "tool_result" not in content
+        assert '"signature"' not in content
+
+
+def test_feed_memex_msg_ids_stable_across_runs(
+    claude_home: Path, tmp_path: Path
+) -> None:
+    """Re-running feed-memex must produce identical msg ids so memex's
+    UNIQUE(source, conversation_id, msg_id) dedupe works on re-import."""
+    runner = CliRunner()
+    inbox = tmp_path / "inbox"
+    inbox.mkdir()
+
+    runner.invoke(
+        main,
+        ["--claude-home", str(claude_home), "feed-memex", "--inbox", str(inbox)],
+    )
+    sample_file = next(inbox.glob("code-*.jsonl"))
+    first_run = sample_file.read_text(encoding="utf-8")
+
+    # Re-run
+    runner.invoke(
+        main,
+        ["--claude-home", str(claude_home), "feed-memex", "--inbox", str(inbox)],
+    )
+    second_run = sample_file.read_text(encoding="utf-8")
+    assert first_run == second_run, "msg ids must be deterministic"
+
+
+def test_feed_memex_dry_run_does_not_write(
+    claude_home: Path, tmp_path: Path
+) -> None:
+    runner = CliRunner()
+    inbox = tmp_path / "inbox"
+    inbox.parent.mkdir(parents=True, exist_ok=True)
+    result = runner.invoke(
+        main,
+        [
+            "--claude-home",
+            str(claude_home),
+            "feed-memex",
+            "--inbox",
+            str(inbox),
+            "--dry-run",
+        ],
+    )
+    assert result.exit_code == 0, result.output
+    assert "Dry run" in result.output or "would write" in result.output.lower()
+    # No files written
+    assert not inbox.exists() or list(inbox.glob("*.jsonl")) == []
+
+
+def test_feed_memex_errors_when_memex_dir_missing(tmp_path: Path) -> None:
+    """If the memex parent doesn't exist (memex not installed), error clearly."""
+    runner = CliRunner()
+    fake_inbox = tmp_path / "no-memex-here" / "inbox"
+    # Create empty Claude Code home so scan succeeds
+    claude_home = tmp_path / "code"
+    (claude_home / "fake-project").mkdir(parents=True)
+    (claude_home / "fake-project" / "x.jsonl").write_text(
+        '{"role":"user","content":"hi","timestamp":"2026-01-01T00:00:00Z"}\n'
+    )
+    result = runner.invoke(
+        main,
+        [
+            "--claude-home",
+            str(claude_home),
+            "feed-memex",
+            "--inbox",
+            str(fake_inbox),
+        ],
+    )
+    assert result.exit_code == 1
+    assert "memex" in result.output.lower()