feat(cli): larql memit — batch fact editing (Phase C of RFC-0001)

[mikeumus]

Summary

Phase C of RFC-0001: wraps the existing covariance-MEMIT solver (`larql_inference::forward::memit::run_memit`) with a CLI, edits.json file format, automatic crown-layer discovery per edit, and a dense patch output format. Stacked on #4 (Phase B).

What this PR adds

Extended patch file format

• Bumped version 1 → 2 with a `kind` field (defaults to `"rank_one"` — Phase B patches round-trip unchanged).
• New `kind = "dense"` variant: flat row-major ΔW matrix. Larger on disk (~72 MB per Gemma 4 4B layer) but semantically exact — no SVD approximation.
• `write_patch` / `read_patch` / `apply_patch` all dispatch on `kind`.
• New `compute_dense()` helper.

New CLI: `larql memit`

1. Reads `edits.json` (a list of `{label, src, new_token, layer?}` records).
2. For each edit: tokenises `src`, resolves `target_token_id`, resolves crown layer (explicit or auto-scan).
3. Calls the existing `run_memit` with a `Vec`, receives one `MemitResult` per affected layer.
4. Serialises each layer's ΔW as a Dense patch into the output directory, plus a `manifest.json`.
5. Prints the `apply-patch` invocation that installs the batch.

Usage

cat > edits.json <<EOF
[
  {\"label\":\"france-to-tokyo\",\"src\":\"Capital of France? A:\",
   \"new_token\":\" Tokyo\",\"layer\":27},
  {\"label\":\"germany-to-rome\",\"src\":\"Capital of Germany? A:\",
   \"new_token\":\" Rome\",\"layer\":27}
]
EOF

larql memit /path/to/gemma4 --edits edits.json --output patches/
larql apply-patch /path/to/gemma4 \\
    -p patches/memit_L27.lqpatch \\
    --prompt \"Capital of France? A:\"

Design choice: dense patches vs low-rank

MEMIT's output ΔW is mathematically rank ≤ N (number of edits at that layer) but isn't stored as a factorisation — the covariance-projected solve naturally produces a dense delta. We could SVD-factorise post-hoc to emit N rank-1 patches, but that adds a lossy approximation step and doubles the code surface for apply-patch.

Choosing "dense" keeps Phase C tight and preserves the exact MEMIT result on disk. File size is large (~72 MB per layer for Gemma 4 4B) but a full batch edit typically touches 1–3 layers, so total patch bundle is 72–216 MB — acceptable for an enterprise MLOps artefact.

If future Phase-D Python consumers want rank-1 factors, they can SVD the dense delta themselves — lossless within numerical precision for ΔW of rank ≤ N.

Known ceiling

Chapter 22 established that single-layer MEMIT with correlated keys (~60% cosine) lands ~3/5 concurrent targets. Users can distribute across crown layers manually via `layer` overrides in edits.json — MEMIT runs independently per layer group.

Leverage of existing code

`forward::memit::run_memit` already implements the full ROME/MEMIT algorithm in Rust (~400 LOC with covariance estimation via `forward::trace::estimate_ffn_covariance`, solve with Tikhonov regularisation). This PR is a CLI veneer on top — no duplication, no math rewrite.

Testing

• `cargo check --package larql-inference` ✓
• `cargo check --package larql-cli` ✓
• Round-trip live testing pending.

Base branch

Targets `feat/edit-command` (#4). After #3 and #4 merge to main, rebase onto main.

Remaining phase

Phase D: `larql-python` bindings (PyO3) exposing `crown`, `edit`, `memit` to Python — lets Colab experiments become one-liner Rust invocations.

🤖 Generated with Claude Code