ltcai 11.5.0 → 11.5.2

package/scripts/generate_rust_parity_fixtures.py

@@ -6,27 +6,23 @@ something keeps proving it is still one. This script is the Python half of that
 proof: it builds a small, fully deterministic Brain with the **real** write path
 (``KnowledgeGraphStore._upsert_node`` / ``_upsert_chunk`` / ``_upsert_edge``,
 the real hash embedder, the real v2 projection and trigram FTS index), then runs
-the real ``hybrid_search`` / ``search`` / ``vector_search`` over it and writes
-their answers to ``rust/fixtures/golden/``.
-
-v11.5.0 widens it past search: the same store also carries the conversation
-corpus, and the same generator drives the KG relationship/traverse reads, the
-service-layer graph and three-channel hybrid, the durable history reads and the
-context assembler (:data:`SUITES`).
-
-Two consumers read what it writes:
-
-* ``tests/unit/test_rust_parity_contract.py`` re-runs the Python engines against
-  the committed database and asserts the goldens still hold — so a change to
-  Python semantics fails loudly instead of silently invalidating the contract
-  the Rust side is pinned to;
-* ``rust/lattice-retrieval/tests/parity.rs`` runs the Rust port against the same
-  database and the same goldens.
-
-Determinism is the whole design constraint: every timestamp is written by the
-real code and then **backdated**; the two ``datetime.now()`` calls the ports
-reach are frozen at :data:`FROZEN_NOW` (recorded in the manifest); LLM concept
-extraction is forced off; every environment knob is pinned to its default.
+the real engines over it and writes their answers to ``rust/fixtures/golden/``.
+The suite set widens with the port (:data:`SUITES`): the search engines
+(v11.4.0); the KG relationship/traverse reads, the service layer, the durable
+history reads and the context assembler (v11.5.0); the document-generation
+search, traversal and context builder (v11.5.1, whose corpus and runners live
+in ``scripts/parity_fixture_corpus_docgen.py``).
+
+Two consumers read what it writes: ``tests/unit/test_rust_parity_contract.py``
+re-runs the Python entry points against the committed database and asserts the
+goldens still hold — so a change to Python semantics fails loudly instead of
+silently invalidating the contract the Rust side is pinned to — and
+``rust/lattice-retrieval/tests/{parity,suites}.rs`` run the Rust ports against
+the same database and the same goldens. Determinism is the whole design
+constraint: every timestamp is written by the real code and then **backdated**;
+every ``datetime.now()`` the ports reach is frozen at :data:`FROZEN_NOW`
+(recorded in the manifest); LLM concept extraction is forced off; every
+environment knob is pinned to its default.
 
 Usage::
 
@@ -47,8 +43,15 @@ from pathlib import Path
 from typing import Any, Callable, Dict, Iterator, List, Optional, Tuple
 
 REPO_ROOT = Path(__file__).resolve().parents[1]
-if str(REPO_ROOT) not in sys.path:
-    sys.path.insert(0, str(REPO_ROOT))
+# The repo (for the product packages) and this directory: `scripts` is not a
+# package, so the docgen corpus is imported by name off the script directory —
+# the same by-path convention the contract test uses to import this file.
+for _import_root in (REPO_ROOT, Path(__file__).resolve().parent):
+    if str(_import_root) not in sys.path:
+        sys.path.insert(0, str(_import_root))
+
+import parity_fixture_corpus_context as context_corpus  # noqa: E402
+import parity_fixture_corpus_docgen as docgen  # noqa: E402
 
 FIXTURE_DIR = REPO_ROOT / "rust" / "fixtures"
 GOLDEN_DIR = FIXTURE_DIR / "golden"
@@ -80,11 +83,11 @@ WS_BETA = "ws-beta"
 # (node_id, type, title, summary, metadata, workspace_id, updated_at)
 #
 # Shaped on purpose: every ``type_boost`` type appears and so do types outside it;
-# titles/summaries are half Korean (the tokenizer, classifier and extractor all
-# branch on script); the ``tie:`` block is five rows sharing one timestamp, one
-# type and nothing to match, pinning the (hits, boost, updated_at) → id ASC
-# tie-break; two workspaces plus NULL-workspace rows cover all three scoping
-# answers (no scoping / empty set / a specific workspace).
+# titles/summaries are half Korean (tokenizer, classifier and extractor all branch
+# on script); the ``tie:`` block is five rows sharing one timestamp, one type and
+# nothing to match, pinning the (hits, boost, updated_at) → id ASC tie-break; two
+# workspaces plus NULL-workspace rows cover all three scoping answers (no scoping
+# / empty set / a specific workspace). The v11.5.1 tail is in the docgen corpus.
 NODES: List[Tuple[str, str, str, str, Dict[str, Any], Optional[str], str]] = [
     ("dec:fusion-alpha", "Decision", "Hybrid retrieval fusion stays alpha weighted",
      "We decided the ranking keeps alpha fusion: lexical rank plus max normalized vector score.",
@@ -186,14 +189,14 @@ NODES: List[Tuple[str, str, str, str, Dict[str, Any], Optional[str], str]] = [
     ("legacy:global-note", "Document", "Legacy global note",
      "A legacy row with no workspace, visible only with include_legacy_global.",
      {}, None, "2026-06-20T10:00:00"),
+    *docgen.DOCGEN_NODES,
 ]
 
 # (chunk_id, parent_node_id, index, node_title, text, chunk_fields, workspace, updated_at)
 #
 # The shape mirrors ``KnowledgeGraphIngestMixin``: every chunk is BOTH a ``Chunk``
-# node (lexical lane + workspace scoping) and a ``chunks`` row with its own
-# embedding (vector lane, rolled up to its parent). Getting that duality wrong is
-# the whole reason chunk-heavy queries are in the query set.
+# node (lexical lane + workspace scoping) and a ``chunks`` row with its own embedding
+# (vector lane, rolled up to its parent) — the duality chunk-heavy queries pin.
 CHUNKS: List[Tuple[str, str, int, str, str, Dict[str, Any], Optional[str], str]] = [
     ("chunk:handbook:1", "doc:handbook", 0, "handbook.pdf chunk 1",
      "온보딩 체크리스트: 첫째, 폴더를 연결합니다. 둘째, 질문을 합니다. 셋째, 근거를 확인합니다.",
@@ -218,10 +221,10 @@ CHUNKS: List[Tuple[str, str, int, str, str, Dict[str, Any], Optional[str], str]]
 # orders by ``weight DESC, created_at DESC, id ASC`` and ``traverse`` caps every BFS
 # round with ``ORDER BY weight DESC, id ASC``, so an edge set sharing one weight and
 # one clock proves nothing. Three shapes are deliberate — a weight tie broken by
-# ``created_at`` (the ``org:lattice`` pair), a weight *and* clock tie broken by edge
-# id (``topic:quality``/``deck:review``), and legacy-global endpoints for scoping.
-# Types are canonicalized by the write door (``relates_to``/``owns`` → ``MENTIONS``),
-# which is why the goldens record uppercase names the fixture never spells.
+# ``created_at`` (``org:lattice``), a weight *and* clock tie broken by edge id
+# (``topic:quality``/``deck:review``), and legacy-global endpoints for scoping. The
+# write door canonicalizes types (``relates_to``/``owns`` → ``MENTIONS``), which is
+# why the goldens record uppercase names the fixture never spells.
 EDGES: List[Tuple[str, str, str, float, str]] = [
     ("dec:fusion-alpha", "concept:retrieval", "mentions", 0.9, "2026-07-01T00:00:00"),
     ("dec:fusion-alpha", "concept:ranking", "mentions", 0.8, "2026-07-02T00:00:00"),
@@ -246,6 +249,7 @@ EDGES: List[Tuple[str, str, str, float, str]] = [
     ("task:onboarding-checklist", "page:onboarding", "relates_to", 0.15, "2026-05-01T00:00:00"),
     ("doc:handbook", "doc:retrieval-spec", "relates_to", 0.1, "2026-05-02T00:00:00"),
     ("tie:a", "tie:b", "relates_to", 1.0, "2026-07-03T00:00:00"),
+    *docgen.DOCGEN_EDGES,
 ]
 
 # ── the conversation corpus (episodic memory, same database file) ────────────
@@ -257,7 +261,7 @@ EDGES: List[Tuple[str, str, str, float, str]] = [
 # ``conversation_id`` (the ``legacy-previous-history`` bucket), a whitespace-only
 # first message (the ``새 대화`` placeholder and its later upgrade), an
 # assistant-first conversation (no upgrade), an empty timestamp (the ``or ""``
-# fallbacks), extra keys ``metadata_json`` merges flat, and ko/en content.
+# fallbacks), extra keys ``metadata_json`` merges flat, ko/en content.
 MESSAGES: List[Tuple[Any, ...]] = [
     ("conv-a", "user", "온보딩 체크리스트 어떻게 시작해?", "jiwon@lattice.ai", "지원", "web", "2026-07-20T09:00:00", WS_ALPHA, "org-1", {}),
     ("conv-a", "assistant", "먼저 폴더를 연결하세요. 그다음 질문하면 됩니다.", "jiwon@lattice.ai", None, "web", "2026-07-20T09:00:05", WS_ALPHA, "org-1", {}),
@@ -307,39 +311,20 @@ QUERIES: List[Dict[str, Any]] = [
     {"key": "ws_alpha", "query": "hybrid retrieval ranking", "allowed": [WS_ALPHA]},
     {"key": "ws_alpha_legacy", "query": "회의 결정 사항", "allowed": [WS_ALPHA], "legacy": True},
     {"key": "ws_beta", "query": "온보딩 체크리스트", "allowed": [WS_BETA]},
-    # A vector floor nothing clears — the only way to reach the stale-embedder
-    # probe and the lexical-only fusion label without breaking the store.
+    # A vector floor nothing clears: the stale-embedder probe and the
+    # lexical-only fusion label, without breaking the store.
     {"key": "min_vector_floor", "query": "hybrid retrieval ranking", "min_vector": 0.95},
     # top_k small enough that the rerank window (top_k * 2) cuts the candidates.
     {"key": "top_k_small", "query": "hybrid retrieval ranking", "top_k": 3},
-    # Pinned alpha: no policy, so no class, no rewrite, and no age decay on a
-    # query that would otherwise be recency-classed.
+    # Pinned alpha: no policy, so no class/rewrite/age decay on a recency query.
     {"key": "alpha_pinned", "query": "지난주 회의 기록", "alpha": 0.2},
-    # A limit below the FTS hit count, so `ORDER BY rank LIMIT ?` decides which
-    # rows exist at all — the one place bm25 ordering (and therefore a SQLite
-    # version difference between the two runtimes) is observable.
+    # A limit below the FTS hit count, so `ORDER BY rank LIMIT ?` decides which rows
+    # exist at all — the one place bm25 ordering (a SQLite version difference) shows.
     {"key": "fts_rank_cut", "query": "Tie candidate", "limit": 2, "top_k": 2},
 ]
 
 #: Every branch of the memories section: a workspace hit, one with no kind and an
 #: empty snippet, a non-workspace row to drop, and one past the limit.
-CONTEXT_MEMORIES: Dict[str, Any] = {
-    "results": [
-        {"id": "mem-1", "kind": "preference", "snippet": "답변은 한국어로", "score": 0.91, "source": "workspace"},
-        {"id": "mem-2", "kind": None, "snippet": "", "score": 0.0, "source": "workspace"},
-        {"id": "mem-3", "kind": "decision", "snippet": "ranking keeps alpha fusion", "score": 0.4, "source": "personal"},
-        {"id": "mem-4", "kind": "fact", "snippet": "온보딩은 다섯 걸음", "score": 0.3, "source": "workspace"},
-    ]
-}
-
-#: A ledger with a pathless row, a non-dict row, and more than the ten-row cut.
-CONTEXT_ARTIFACTS: List[Any] = [
-    {"path": "notes/ranking.md", "at": "2026-07-20T09:00:00", "run_id": "run-1"},
-    {"path": "notes/onboarding.md", "run_id": "run-2"},
-    {"path": "", "at": "2026-07-20T09:00:01"},
-    "not-a-dict",
-] + [{"path": f"out/file-{index}.md", "at": None, "run_id": f"r{index}"} for index in range(10)]
-
 #: The Phase-2/3 suites: one spec list per ported entry point.
 SUITES: Dict[str, List[Dict[str, Any]]] = {
     "relationship": [
@@ -403,8 +388,8 @@ SUITES: Dict[str, List[Dict[str, Any]]] = {
         {"key": "en_code", "query": "vector_search() returns"},
         {"key": "ko_person", "query": "담당자 누구"},
         {"key": "en_filler", "query": "  what is   the retrieval specification please  "},
-        # Explicit weights disable BOTH the rewrite and the age decay, on a
-        # query that would otherwise get both. That asymmetry is the contract.
+        # Explicit weights disable BOTH rewrite and age decay on a query that
+        # would otherwise get both — that asymmetry is the contract.
         {"key": "pinned_recency", "query": "지난주 회의 기록", "weights": {"keyword": 0.5, "vector": 0.3, "graph": 0.2}},
         {"key": "pinned_partial", "query": "hybrid retrieval ranking", "weights": {"graph": 1.0}},
         {"key": "pinned_zero", "query": "회의 결정 사항", "weights": {"keyword": 0.0, "vector": 0.0, "graph": 0.0}},
@@ -461,21 +446,9 @@ SUITES: Dict[str, List[Dict[str, Any]]] = {
         {"key": "limit_one", "query": "ranking", "limit": 1},
         {"key": "scoped_strict", "query": "ranking", "allowed": [WS_BETA], "legacy": False},
     ],
-    "context_assemble": [
-        {"key": "all_seams", "query": "회의 결정 사항", "memories": CONTEXT_MEMORIES, "artifacts": CONTEXT_ARTIFACTS, "notes": "정원 노트: 랭킹은 alpha 융합을 유지한다.", "recent": {"limit": 4}},
-        {"key": "knowledge_only", "query": "hybrid retrieval ranking"},
-        {"key": "no_seams", "query": "hybrid retrieval ranking", "knowledge": False},
-        {"key": "memories_only", "query": "온보딩", "knowledge": False, "memories": CONTEXT_MEMORIES, "memory_limit": 2},
-        {"key": "artifacts_only", "query": "온보딩", "knowledge": False, "artifacts": CONTEXT_ARTIFACTS},
-        {"key": "notes_blank", "query": "온보딩", "knowledge": False, "notes": "   "},
-        {"key": "recent_conversation", "query": "온보딩", "knowledge": False, "recent": {"conversation_id": "conv-a", "limit": 10}},
-        {"key": "recent_personal_workspace", "query": "온보딩", "knowledge": False, "recent": {"workspace_id": "personal", "limit": 6}},
-        {"key": "recent_user_scoped", "query": "온보딩", "knowledge": False, "recent": {"user_email": "jiwon@lattice.ai", "limit": 5}},
-        {"key": "budget_tiny", "query": "회의 결정 사항", "memories": CONTEXT_MEMORIES, "artifacts": CONTEXT_ARTIFACTS, "notes": "정원 노트: 랭킹은 alpha 융합을 유지한다.", "recent": {"limit": 4}, "budget": 20},
-        {"key": "budget_one", "query": "회의 결정 사항", "memories": CONTEXT_MEMORIES, "artifacts": CONTEXT_ARTIFACTS, "notes": "노트", "recent": {"limit": 4}, "budget": 1},
-        {"key": "budget_zero", "query": "회의 결정 사항", "memories": CONTEXT_MEMORIES, "notes": "노트", "budget": 0},
-        {"key": "knowledge_limit_one", "query": "hybrid retrieval ranking", "knowledge_limit": 1},
-    ],
+    **context_corpus.CONTEXT_SUITES,
+    # v11.5.1: the document-generation ports, specs and runners alike.
+    **docgen.DOCGEN_SUITES,
 }
 
 #: Texts whose tokenizer output, hashes and vectors pin the embedding port.
@@ -517,10 +490,12 @@ def pinned_environment() -> Iterator[None]:
 def frozen_clock() -> Iterator[None]:
     """Freeze every ported ``datetime.now()`` at :data:`FROZEN_NOW`.
 
-    Only the recency-class age decay reads the clock, through the ``datetime``
-    name its module imported — so rebinding that name is the whole patch. Two
-    modules do it: the graph-layer and the service-layer ``hybrid_search``.
+    Only the recency decay reads the clock, through the ``datetime`` name its
+    module imported, so rebinding that name is the whole patch. Three modules
+    reach it: the graph-layer and service-layer ``hybrid_search``, and the
+    document-generation search's own 14-day half-life.
     """
+    from lattice_brain.graph import retrieval_docgen as docgen_module
     from lattice_brain.graph.retrieval import hybrid as hybrid_module
     from latticeai.services import search_service as service_module
 
@@ -531,7 +506,7 @@ def frozen_clock() -> Iterator[None]:
         def now(cls, tz=None):  # noqa: ARG003 — mirrors datetime.now's signature
             return frozen
 
-    modules = (hybrid_module, service_module)
+    modules = (hybrid_module, service_module, docgen_module)
     originals = [module.datetime for module in modules]
     for module in modules:
         module.datetime = _FrozenDatetime
@@ -546,8 +521,8 @@ def frozen_clock() -> Iterator[None]:
 def rules_only_extraction() -> Iterator[None]:
     """Force ``_topic_candidates`` down its rule-based path.
 
-    The LLM path needs a bound router no fixture run has, but "no router happens
-    to be bound" is an accident and this contract cannot rest on one.
+    The LLM path needs a bound router no fixture run has, but "no router
+    happens to be bound" is an accident this contract cannot rest on.
     """
     from lattice_brain.graph._kg_common import extraction
 
@@ -618,13 +593,12 @@ def build_store(db_path: Path) -> None:
         for from_node, to_node, edge_type, weight, stamp in EDGES:
             # ``_upsert_edge`` stamps ``created_at`` from the wall clock in BOTH
             # tables, and the read path is the ``kgv2_edges`` view over ``edges_v2``:
-            # backdating only the legacy table (as this generator first did) left
-            # the relationship ordering moving with the clock.
+            # backdating only the legacy table left the ordering moving with the clock.
             edge_id = store._upsert_edge(conn, from_node, to_node, edge_type, weight, {})
             conn.execute("UPDATE edges SET created_at=? WHERE id=?", (stamp, edge_id))
             conn.execute("UPDATE edges_v2 SET created_at=? WHERE id=?", (stamp, edge_id))
-        # ``indexed_at`` decides the candidate scan order (and, when the cap bites,
-        # which candidates exist at all), so it is assigned rather than inherited.
+        # ``indexed_at`` decides the candidate scan order (and, when the cap
+        # bites, which candidates exist), so it is assigned rather than inherited.
         item_ids = [row["item_id"] for row in conn.execute(
             "SELECT item_id FROM vector_embeddings ORDER BY item_id ASC"
         ).fetchall()]
@@ -636,8 +610,8 @@ def build_store(db_path: Path) -> None:
     store.record_embedder_fingerprint()
     write_conversations(db_path)
 
-    # Leave one self-contained file behind: checkpoint the WAL, drop back to a
-    # rollback journal so no sidecar is committed, and compact.
+    # One self-contained file: checkpoint the WAL, drop to a rollback journal
+    # so no sidecar is committed, and compact.
     with sqlite3.connect(str(db_path)) as conn:
         conn.execute("PRAGMA wal_checkpoint(TRUNCATE)")
         conn.execute("PRAGMA journal_mode=DELETE")
@@ -678,18 +652,18 @@ def run_engine(store, engine: str, spec: Dict[str, Any]) -> Dict[str, Any]:
         return ENGINES[engine](store, spec)
 
 
-# ── suites (v11.5.0): KG reads, the service layer, history, context ──────────
+# ── the suites beyond search (v11.5.0/v11.5.1) ───────────────────────────────
 #
 # The Phase-1 engines share one query shape (a query set × an engine set); the
-# Phase-2/3 ports do not, so each gets its own spec list and runner, both carried
-# in the manifest so Rust and Python enumerate exactly the same work.
+# later ports do not, so each gets its own spec list and runner, both carried in
+# the manifest so Rust and Python enumerate exactly the same work.
 
 
 class Harness:
     """Every Python entry point the v11.5.0 goldens are produced from.
 
     ``require_auth=False`` is the loopback-owner configuration the native routes
-    reproduce: the history scope is whatever the caller passes explicitly.
+    reproduce: the history scope is whatever the caller passes.
     """
 
     def __init__(self, db_path: Path):
@@ -718,8 +692,7 @@ def _history_scope(spec: Dict[str, Any]) -> Dict[str, Any]:
     """The identity/workspace scope every history read takes.
 
     ``include_legacy_global`` defaults to ``True`` — ``ConversationStore``'s own
-    default, the opposite of the graph layer's and the kind of asymmetry a port
-    gets wrong.
+    default, the opposite of the graph layer's and an asymmetry a port gets wrong.
     """
     allowed = spec.get("allowed")
     return {
@@ -796,68 +769,6 @@ def _run_history_search(h: Harness, spec: Dict[str, Any]) -> List[Dict[str, Any]
     )
 
 
-def _context_seams(h: Harness, spec: Dict[str, Any]) -> Dict[str, Any]:
-    """The seam set for one context spec — data seams plus the real engines.
-
-    ``memories`` / ``artifacts`` / ``notes`` are *data* seams: the payload is the
-    spec, so both runtimes feed the assembler the same bytes and what is under
-    test is the assembler. ``knowledge`` and ``recent`` are real — the
-    service-layer hybrid search and the durable history reader.
-    """
-    from latticeai.api.chat_helpers import build_recent_chat_context
-
-    # Signatures matter: the assembler inspects them to decide which context
-    # fields a seam may be handed, so each one declares exactly what it accepts.
-    seams: Dict[str, Any] = {}
-    if spec.get("memories") is not None:
-        memories = spec["memories"]
-        seams["memory_recall"] = (
-            lambda query, *, user_email=None, workspace_id=None, limit=5: memories
-        )
-    if spec.get("artifacts") is not None:
-        artifacts = spec["artifacts"]
-        seams["recent_artifacts"] = (
-            lambda *, user_email=None, conversation_id=None, workspace_id=None: artifacts
-        )
-    if spec.get("knowledge", True):
-        # Loopback trust: no workspace scoping, exactly as on the native route.
-        seams["hybrid_search"] = (
-            lambda query, *, limit=5, user_email=None, workspace_id=None:
-            h.service.hybrid_search(query, limit=limit)
-        )
-    if spec.get("notes") is not None:
-        notes = spec["notes"]
-        seams["notes_context"] = lambda query, *, user_email=None, workspace_id=None: notes
-    if spec.get("recent") is not None:
-        recent = spec["recent"]
-        seams["recent_chat"] = (
-            lambda *, user_email=None, conversation_id=None, workspace_id=None:
-            build_recent_chat_context(
-                get_history=h.history_runtime["get_history"],
-                limit=recent.get("limit", 10),
-                include_image_missing_replies=recent.get("images", True),
-                user_email=recent.get("user_email"),
-                conversation_id=recent.get("conversation_id"),
-                workspace_id=recent.get("workspace_id"),
-            )
-        )
-    return seams
-
-
-def _run_context_assemble(h: Harness, spec: Dict[str, Any]) -> Dict[str, Any]:
-    from lattice_brain.context import ContextAssembler
-
-    assembled = ContextAssembler(**_context_seams(h, spec)).assemble(
-        spec["query"], user_email=spec.get("user_email"),
-        workspace_id=spec.get("workspace_id"),
-        conversation_id=spec.get("conversation_id"), budget=spec.get("budget", 2000),
-        memory_limit=spec.get("memory_limit", 5),
-        knowledge_limit=spec.get("knowledge_limit", 5),
-    )
-    return {"text": assembled.text, "approx_tokens": assembled.approx_tokens,
-            "trace": assembled.trace()}
-
-
 SUITE_RUNNERS: Dict[str, Callable[[Harness, Dict[str, Any]], Any]] = {
     "relationship": _run_relationship,
     "traverse": _run_traverse,
@@ -867,7 +778,8 @@ SUITE_RUNNERS: Dict[str, Callable[[Harness, Dict[str, Any]], Any]] = {
     "conversations": _run_conversations,
     "conversation_messages": _run_conversation_messages,
     "history_search": _run_history_search,
-    "context_assemble": _run_context_assemble,
+    **context_corpus.CONTEXT_RUNNERS,
+    **docgen.DOCGEN_RUNNERS,
 }
 
 
@@ -901,7 +813,7 @@ def suite_payload(suite: str, spec: Dict[str, Any], result: Any) -> Dict[str, An
     """One suite golden: the spec that produced it, verbatim, and the answer.
 
     The spec rides along rather than being flattened into a fixed ``params``
-    block: these entry points share no parameter shape.
+    block — these entry points share no parameter shape.
     """
     return {"suite": suite, "key": spec["key"], "spec": spec, "result": result}
 
@@ -982,8 +894,7 @@ def main() -> int:
         _dump(GOLDEN_DIR / "embeddings_golden.json", embeddings_golden())
         _dump(GOLDEN_DIR / "rounding_golden.json", rounding_golden())
         _dump(GOLDEN_DIR / "manifest.json", manifest())
-    # ``KnowledgeGraphStore.__init__`` creates its blob directory eagerly and the
-    # fixture has no blobs; an empty directory beside an artefact is just noise.
+    # The store creates its blob directory eagerly and the fixture has no blobs.
     blob_dir = STORE_PATH.parent / "blobs"
     if blob_dir.is_dir() and not any(blob_dir.iterdir()):
         blob_dir.rmdir()

package/scripts/parity_fixture_corpus_context.py

@@ -0,0 +1,162 @@
+#!/usr/bin/env python3
+"""The context-assembly half of the Python↔Rust parity corpus (v11.5.2).
+
+``scripts/generate_rust_parity_fixtures.py`` owns the store, the harness and the
+goldens; this module owns the specs and runners for the two context ports, so
+neither file grows past the tree's file-size ceiling. The split follows the
+``parity_fixture_corpus_docgen`` precedent: specs and their runners live side by
+side, because a spec list that arrives without the runner that answers it is a
+suite that silently checks nothing.
+
+Two ports, deliberately separate:
+
+* **``context_assemble``** pins :class:`~lattice_brain.context.ContextAssembler`
+  over the seams the *production* assembler supplies
+  (``latticeai/runtime/context_runtime.py``): memories, artifacts, hybrid
+  knowledge and garden notes. It does **not** supply ``recent_chat`` — that seam
+  has never been wired live, and a golden that pinned it claimed cross-runtime
+  agreement about a code path the product does not execute.
+* **``recent_chat``** pins the recent-conversation transcript as the product
+  really builds it: ``chat.py`` prepends ``build_recent_chat_context(...)`` on
+  every non-hybrid turn and the agent loop injects the same text each executor
+  step. Its Rust twin is ``lattice_retrieval::history::recent_chat``.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Callable, Dict, List
+
+#: ``h`` is the generator's ``Harness``. It is typed ``Any`` rather than
+#: imported: the harness owns the live store and the service layer, so importing
+#: it here would make the corpus depend on the generator that imports *it*.
+
+#: The organization workspace the corpus seeds; the same literal the generator
+#: and the docgen corpus use.
+WS_ALPHA = "ws-alpha"
+
+CONTEXT_MEMORIES: Dict[str, Any] = {
+    "results": [
+        {"id": "mem-1", "kind": "preference", "snippet": "답변은 한국어로", "score": 0.91, "source": "workspace"},
+        {"id": "mem-2", "kind": None, "snippet": "", "score": 0.0, "source": "workspace"},
+        {"id": "mem-3", "kind": "decision", "snippet": "ranking keeps alpha fusion", "score": 0.4, "source": "personal"},
+        {"id": "mem-4", "kind": "fact", "snippet": "온보딩은 다섯 걸음", "score": 0.3, "source": "workspace"},
+    ]
+}
+
+#: A ledger with a pathless row, a non-dict row, and more than the ten-row cut.
+CONTEXT_ARTIFACTS: List[Any] = [
+    {"path": "notes/ranking.md", "at": "2026-07-20T09:00:00", "run_id": "run-1"},
+    {"path": "notes/onboarding.md", "run_id": "run-2"},
+    {"path": "", "at": "2026-07-20T09:00:01"},
+    "not-a-dict",
+] + [{"path": f"out/file-{index}.md", "at": None, "run_id": f"r{index}"} for index in range(10)]
+
+def _context_seams(h: Any, spec: Dict[str, Any]) -> Dict[str, Any]:
+    """The seam set for one context spec — data seams plus the real engines.
+
+    ``memories`` / ``artifacts`` / ``notes`` are *data* seams: the payload is the
+    spec, so both runtimes feed the assembler the same bytes and what is under
+    test is the assembler. ``knowledge`` is a real engine — the service-layer
+    hybrid search.
+
+    There is deliberately no ``recent_chat`` seam here: the production
+    assembler does not supply one, so a golden that did would pin agreement
+    about a path neither runtime reaches in the product. The recent transcript
+    is pinned by the ``recent_chat`` suite instead.
+    """
+    # Signatures matter: the assembler inspects them to decide which context
+    # fields a seam may be handed, so each one declares exactly what it accepts.
+    seams: Dict[str, Any] = {}
+    if spec.get("memories") is not None:
+        memories = spec["memories"]
+        seams["memory_recall"] = (
+            lambda query, *, user_email=None, workspace_id=None, limit=5: memories
+        )
+    if spec.get("artifacts") is not None:
+        artifacts = spec["artifacts"]
+        seams["recent_artifacts"] = (
+            lambda *, user_email=None, conversation_id=None, workspace_id=None: artifacts
+        )
+    if spec.get("knowledge", True):
+        # Loopback trust: no workspace scoping, exactly as on the native route.
+        seams["hybrid_search"] = (
+            lambda query, *, limit=5, user_email=None, workspace_id=None:
+            h.service.hybrid_search(query, limit=limit)
+        )
+    if spec.get("notes") is not None:
+        notes = spec["notes"]
+        seams["notes_context"] = lambda query, *, user_email=None, workspace_id=None: notes
+    return seams
+
+
+def _run_context_assemble(h: Any, spec: Dict[str, Any]) -> Dict[str, Any]:
+    from lattice_brain.context import ContextAssembler
+
+    assembled = ContextAssembler(**_context_seams(h, spec)).assemble(
+        spec["query"], user_email=spec.get("user_email"),
+        workspace_id=spec.get("workspace_id"),
+        conversation_id=spec.get("conversation_id"), budget=spec.get("budget", 2000),
+        memory_limit=spec.get("memory_limit", 5),
+        knowledge_limit=spec.get("knowledge_limit", 5),
+    )
+    return {"text": assembled.text, "approx_tokens": assembled.approx_tokens,
+            "trace": assembled.trace()}
+
+
+def _run_recent_chat(h: Any, spec: Dict[str, Any]) -> str:
+    """The recent-conversation transcript, exactly as ``/chat`` builds it."""
+    from latticeai.api.chat_helpers import build_recent_chat_context
+
+    return build_recent_chat_context(
+        get_history=h.history_runtime["get_history"],
+        limit=spec.get("limit", 10),
+        include_image_missing_replies=spec.get("images", True),
+        user_email=spec.get("user_email"),
+        conversation_id=spec.get("conversation_id"),
+        workspace_id=spec.get("workspace_id"),
+    )
+
+
+#: The two context suites, as the generator merges them into :data:`SUITES` /
+#: :data:`SUITE_RUNNERS`.
+CONTEXT_SUITES: Dict[str, List[Dict[str, Any]]] = {
+    # 11.5.2: these pin the assembler over the seams the *production* assembler
+    # supplies (`latticeai/runtime/context_runtime.py`). The `recent_chat` seam
+    # is not one of them — it has never been wired live — so pinning it here
+    # claimed cross-runtime agreement about a code path the product does not
+    # run. The recent-conversation text itself is still pinned, in the
+    # `recent_chat` suite below, against the function chat really calls.
+    "context_assemble": [
+        {"key": "all_seams", "query": "회의 결정 사항", "memories": CONTEXT_MEMORIES, "artifacts": CONTEXT_ARTIFACTS, "notes": "정원 노트: 랭킹은 alpha 융합을 유지한다."},
+        {"key": "knowledge_only", "query": "hybrid retrieval ranking"},
+        {"key": "no_seams", "query": "hybrid retrieval ranking", "knowledge": False},
+        {"key": "memories_only", "query": "온보딩", "knowledge": False, "memories": CONTEXT_MEMORIES, "memory_limit": 2},
+        {"key": "artifacts_only", "query": "온보딩", "knowledge": False, "artifacts": CONTEXT_ARTIFACTS},
+        {"key": "notes_blank", "query": "온보딩", "knowledge": False, "notes": "   "},
+        {"key": "budget_tiny", "query": "회의 결정 사항", "memories": CONTEXT_MEMORIES, "artifacts": CONTEXT_ARTIFACTS, "notes": "정원 노트: 랭킹은 alpha 융합을 유지한다.", "budget": 20},
+        {"key": "budget_one", "query": "회의 결정 사항", "memories": CONTEXT_MEMORIES, "artifacts": CONTEXT_ARTIFACTS, "notes": "노트", "budget": 1},
+        {"key": "budget_zero", "query": "회의 결정 사항", "memories": CONTEXT_MEMORIES, "notes": "노트", "budget": 0},
+        {"key": "knowledge_limit_one", "query": "hybrid retrieval ranking", "knowledge_limit": 1},
+    ],
+    # The recent-conversation transcript as the product actually builds it:
+    # `chat.py` prepends `build_recent_chat_context(...)` on every non-hybrid
+    # turn, and the agent loop injects the same text each executor step. This
+    # is the live twin of `lattice_retrieval::history::recent_chat`.
+    "recent_chat": [
+        {"key": "everything"},
+        {"key": "conversation", "conversation_id": "conv-a"},
+        {"key": "conversation_missing", "conversation_id": "nope"},
+        {"key": "personal_workspace", "workspace_id": "personal", "limit": 6},
+        {"key": "workspace_alpha", "workspace_id": WS_ALPHA},
+        {"key": "user_scoped", "user_email": "jiwon@lattice.ai", "limit": 5},
+        {"key": "user_and_conversation", "user_email": "jiwon@lattice.ai", "conversation_id": "conv-a"},
+        {"key": "limit_one", "limit": 1},
+        {"key": "limit_zero", "limit": 0},
+        {"key": "image_replies_dropped", "images": False},
+    ],
+}
+
+CONTEXT_RUNNERS: Dict[str, Callable[..., Any]] = {
+    "context_assemble": _run_context_assemble,
+    "recent_chat": _run_recent_chat,
+}