proof(stage-d): pre-declare fusion-spec v1 and the B1_clean arm before the first DEV look

The ruler requires the retrieval configuration on record before the number is
seen. B1_clean = prose-only FTS (porter unicode61) over the archive-ingested
learning-memory store, phrase-token planner, bm25 over 200 event rows, first 5
distinct session ids. No fusion, no claims, no embeddings — the arm that answers
'what does cleaning buy' and nothing else. Wire-tested on synthetic questions only.

Author: NetDevAutomate

docs/architecture/session-memory/receipts/fusion-spec-v1.md

@@ -0,0 +1,46 @@
+# Fusion spec v1 — arms pre-declared before the first DEV look
+
+**Declared:** 2026-09-10, before any DEV look on `learning-memory.db`. Ruler clause: "the fused
+arm's algorithm, per-source candidate budget, dedup rule and tie-break are versioned in
+`receipts/fusion-spec-v<N>.md` before the first DEV look; every arm returns exactly five results
+within the same byte budget." No arm below fuses more than one source yet; the spec exists so the
+retrieval configuration in force is on record before the number is seen.
+
+## Controls (ruler, unchanged)
+
+- **B0** — shipped `session_search` at pin `031dbab9`: `_session_search_queries` (AND then OR),
+  `bm25(messages_fts)`, scope visibility, LIMIT 200 message rows → first 5 distinct session ids.
+- **B1** — the same path at the candidate commit. Non-inferiority of B1 vs B0 gates everything.
+
+## Arm `B1_clean` (Stage D, "what cleaning buys")
+
+*Question it answers:* does removing tool echo and exporter duplicates from the indexed text —
+and planning natural language so the query cannot throw — lift session recall, before any
+derivation, claims, embeddings or ontology exist?
+
+- **Store:** `~/.local/share/studyloop/knowledge-proof/learning-memory.db`, schema v2, ingested by
+  `archive-v1` / `archive-classifier-v1` (receipt `ingest-archive-v1.json`). Opened read-only.
+- **Index:** `prose_fts` — external content over `prose_events` (`user`, `assistant_prose` only),
+  tokenizer `porter unicode61` (the schema default; `unicode61` is a later, separate arm).
+- **Query planning:** `Store.search_prose` planner — every whitespace token phrase-quoted, OR-joined,
+  control/surrogate code points stripped. No AND stage (a deliberate difference from B1: the
+  AND→OR fallback is the part of the shipped planner that crashes; measured, not assumed, by the
+  42 DEV errors in the baseline receipt).
+- **Ranking:** `bm25(prose_fts)` ascending over event rows; **candidate budget 200 event rows**;
+  session id = the event's `session_id`; first **5 distinct session ids** in rank order.
+- **Dedup rule:** by session id, first occurrence wins. **Tie-break:** bm25 then `events.id`
+  ascending (ingest order).
+- **Byte budget:** identical to B1 — the arm returns ids only; payload budgets apply at Stage G.
+- **Latency:** measured cold on a fresh connection per receipt run; p95 ≤ 500 ms and ≤ 2 × B1.
+
+## What is *not* in v1
+
+No claims arm, no embeddings, no metadata filters, no lineage roll-up, no RRF. Each of those is a
+later spec version, declared before its own first look. The `unicode61` tokenizer variant is a
+separate arm (`B1_clean_u61`) that requires a second store build and is declared here only by name.
+
+## Look accounting for Stage D
+
+This look is the first of ≤ 4 DEV looks for the **G1** family. Improvement = the paired lower
+bound vs B1 rose. It is scored on gold **DEV** (`gold-v2-dev.json`, sha `eeca2aaf…`); the SEALED
+set is not touched by any Stage D activity.

scripts/knowledge_proof/proof_arms.py

@@ -0,0 +1,71 @@
+"""Feature arms for ``score.py`` (``--feature proof_arms:<name>``).
+
+Every arm here is declared in ``receipts/fusion-spec-v<N>.md`` *before* its first DEV
+look; the docstring of each factory names the spec version it implements so a receipt
+can be checked against the declaration mechanically.
+
+Arms that read ``learning-memory.db`` open their own read-only connection and ignore
+the archive connection ``score.py`` passes in: the harness's contract is
+``Arm = Callable[[sqlite3.Connection, str], list[str]]`` and the store is a different
+database from the gold's corpus. Session ids are identical across the two (ADR-0011 §6),
+which is what makes the same gold score both.
+"""
+
+from __future__ import annotations
+
+import os
+import pathlib
+import sqlite3
+from collections.abc import Callable
+
+Arm = Callable[[sqlite3.Connection, str], list[str]]
+
+K = 5
+CANDIDATE_ROWS = 200
+STORE_ENV = "KNOWLEDGE_PROOF_STORE"
+DEFAULT_STORE = pathlib.Path.home() / ".local/share/studyloop/knowledge-proof/learning-memory.db"
+
+
+def _store_path() -> pathlib.Path:
+    return pathlib.Path(os.environ.get(STORE_ENV, str(DEFAULT_STORE)))
+
+
+def _open_store_ro(path: pathlib.Path) -> sqlite3.Connection:
+    if not path.exists():
+        raise FileNotFoundError(f"learning-memory store not found: {path}")
+    return sqlite3.connect(f"file:{path}?mode=ro", uri=True)
+
+
+def B1_clean() -> Arm:  # noqa: N802 - arm names are receipt labels, matched to the spec
+    """fusion-spec-v1 ``B1_clean``: prose-only FTS over the archive-ingested store.
+
+    Planner = ``learning_memory.store.plan_prose_query`` (phrase-quote every token, OR-join,
+    strip control/surrogate code points); ranking = ``bm25(prose_fts)`` over
+    ``CANDIDATE_ROWS`` event rows; dedup by session id, first occurrence wins;
+    tie-break bm25 then ``events.id``; exactly the first ``K`` distinct session ids.
+    """
+    from learning_memory.store import plan_prose_query
+
+    conn = _open_store_ro(_store_path())
+
+    def arm(_archive: sqlite3.Connection, question: str) -> list[str]:
+        planned = plan_prose_query(question)
+        if not planned:
+            return []
+        rows = conn.execute(
+            "SELECT e.session_id FROM prose_fts "
+            "JOIN events AS e ON e.id = prose_fts.rowid "
+            "WHERE prose_fts MATCH ? "
+            "ORDER BY bm25(prose_fts), e.id "
+            f"LIMIT {CANDIDATE_ROWS}",
+            (planned,),
+        ).fetchall()
+        seen: list[str] = []
+        for (sid,) in rows:
+            if sid not in seen:
+                seen.append(sid)
+                if len(seen) == K:
+                    break
+        return seen
+
+    return arm