ltcai 11.5.1 → 11.5.2

package/latticeai/setup/auto_setup.py

@@ -47,6 +47,7 @@ from dataclasses import asdict, dataclass, field
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple
 
+from latticeai.core.module_probe import module_available
 from latticeai.core.quiet import quiet
 from latticeai.services.process_audit import (
     CommandConfirmationError,
@@ -59,6 +60,8 @@ from latticeai.services.setup_detection import (
     detect_cuda,
     detect_tools,
     detect_wsl_from_text,
+    parse_windows_cpu_info,
+    windows_processor_features,
 )
 from latticeai.services.setup_detection import (
     parse_windows_video_controllers as _parse_windows_video_controllers,
@@ -282,37 +285,23 @@ def _detect_cpu_details(prof_os: str) -> Tuple[str, int, int, List[str]]:
                 flags = line.split(":", 1)[-1].strip().lower().split()
     elif prof_os == "windows":
         raw = _run(["wmic", "cpu", "get", "Name,NumberOfCores,NumberOfLogicalProcessors", "/format:list"])
-        for line in raw.splitlines():
-            key, _, value = line.partition("=")
-            if key == "Name" and value.strip():
-                model = value.strip()
-            elif key == "NumberOfCores" and value.strip():
-                try:
-                    physical = int(value.strip())
-                except ValueError:
-                    quiet()
-            elif key == "NumberOfLogicalProcessors" and value.strip():
-                try:
-                    logical = int(value.strip())
-                except ValueError:
-                    quiet()
-        try:
-            import ctypes
-            kernel32 = ctypes.windll.kernel32  # type: ignore[attr-defined]  # Windows-only
-            feature_map = {6: "sse", 10: "sse2", 13: "sse3", 19: "neon", 28: "rdrand"}
-            flags.extend(name for code, name in feature_map.items() if kernel32.IsProcessorFeaturePresent(code))
-        except Exception:
-            quiet()
+        model, physical, logical = parse_windows_cpu_info(
+            raw, model=model, physical_cores=physical, logical_cores=logical,
+        )
+        flags.extend(windows_processor_features())
     interesting = {"avx", "avx2", "avx512f", "fma", "neon", "sse4_2", "sse", "sse2", "sse3", "rdrand"}
     return model, physical, logical, sorted({flag for flag in flags if flag in interesting})
 
 
 def _has_module(name: str) -> bool:
-    try:
-        __import__(name)
-        return True
-    except Exception:
-        return False
+    """Importable *and loadable*.
+
+    ``strict=True`` on purpose: this probe drives what the setup wizard offers
+    to install, and an ``mlx`` wheel built for another architecture has a
+    findable spec right up until it raises on load. Answering from the spec
+    alone would plan a runtime that cannot start.
+    """
+    return module_available(name, strict=True)
 
 
 def probe() -> SystemProfile:

package/latticeai/setup/wizard/catalog.py

@@ -10,6 +10,8 @@ from __future__ import annotations
 import re
 from typing import Dict, List, Tuple
 
+from latticeai.services.model_catalog import _version_tuple as _catalog_version_tuple
+
 # ── Model Catalog ─────────────────────────────────────────────────────────────
 # (model_id, display_name, size_gb, tag, description, min_ram_gb)
 # 11.2.0: 모든 repo id 를 2026-08-10 Hugging Face API 로 확인했다 — 존재 여부,
@@ -127,8 +129,9 @@ _BEST_MODEL_TIERS: Dict[str, List[Tuple[int, str]]] = {
 }
 
 
-def _version_tuple(raw: str) -> Tuple[int, ...]:
-    return tuple(int(part) for part in raw.split(".") if part.isdigit())
+
+#: The engine catalog owns this parse; the wizard compares the same strings.
+_version_tuple = _catalog_version_tuple
 
 
 def _catalog_row_family_version(row: Tuple[str, str, float, str, str, int]) -> Tuple[str, Tuple[int, ...]] | None:

package/latticeai/setup/wizard/detect.py

@@ -21,6 +21,8 @@ from latticeai.services.setup_detection import (
     detect_cuda,
     detect_tools,
     detect_wsl_from_text,
+    parse_windows_cpu_info,
+    windows_processor_features,
 )
 from latticeai.services.setup_detection import (
     parse_windows_video_controllers as _parse_windows_video_controllers,
@@ -98,33 +100,10 @@ def _detect_cpu() -> Dict[str, Any]:
             quiet()
     elif platform.system() == "Windows":
         raw = _cmd(["wmic", "cpu", "get", "Name,NumberOfCores,NumberOfLogicalProcessors", "/format:list"], timeout=5)
-        for line in raw.splitlines():
-            key, _, value = line.partition("=")
-            if key == "Name" and value.strip():
-                model = value.strip()
-            elif key == "NumberOfCores" and value.strip():
-                try:
-                    physical_cores = int(value.strip())
-                except ValueError:
-                    quiet()
-            elif key == "NumberOfLogicalProcessors" and value.strip():
-                try:
-                    logical_cores = int(value.strip())
-                except ValueError:
-                    quiet()
-        try:
-            import ctypes
-            kernel32 = ctypes.windll.kernel32  # type: ignore[attr-defined]  # Windows-only
-            feature_map = {
-                6: "sse",
-                10: "sse2",
-                13: "sse3",
-                19: "neon",
-                28: "rdrand",
-            }
-            flags.extend(name for code, name in feature_map.items() if kernel32.IsProcessorFeaturePresent(code))
-        except Exception:
-            quiet()
+        model, physical_cores, logical_cores = parse_windows_cpu_info(
+            raw, model=model, physical_cores=physical_cores, logical_cores=logical_cores,
+        )
+        flags.extend(windows_processor_features())
     interesting = {"avx", "avx2", "avx512f", "fma", "neon", "sse4_2"}
     if platform.system() == "Windows":
         interesting.update({"sse", "sse2", "sse3", "rdrand"})

package/latticeai/setup/wizard/paths.py

@@ -20,6 +20,8 @@ import shutil
 from pathlib import Path
 from typing import Any, Dict, List
 
+from latticeai.core.module_probe import module_available as _module_available
+
 OFFICIAL_DOWNLOADS: Dict[str, str] = {
     "homebrew": "https://brew.sh",
     "python": "https://www.python.org/downloads/",
@@ -149,11 +151,6 @@ def _which_detail(binary: str) -> Dict[str, Any]:
     return {"installed": path is not None, "path": path}
 
 
-def _module_available(module_name: str) -> bool:
-    import importlib.util
-    return importlib.util.find_spec(module_name) is not None
-
-
 def _package_module(package: str) -> str:
     return PACKAGE_MODULES.get(package, package.replace("-", "_").split("[", 1)[0])
 

package/latticeai/setup/wizard/plans.py

@@ -8,15 +8,15 @@ plan and therefore nothing to confirm.
 
 from __future__ import annotations
 
-import json as _json
 import sys
 from typing import Any, Dict, List
 
+from latticeai.core.sse import sse_frame
 from latticeai.services.process_audit import command_plan_for_commands
 
 
 def _sse(data: Dict) -> str:
-    return f"data: {_json.dumps(data, ensure_ascii=False)}\n\n"
+    return sse_frame(None, data)
 
 
 def _action_commands(action: Dict[str, Any]) -> List[List[str]]:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ltcai",
-  "version": "11.5.1",
+  "version": "11.5.2",
   "description": "Lattice AI — local-first Digital Brain that keeps your knowledge durable across any AI model.",
   "homepage": "https://github.com/TaeSooPark-PTS/LatticeAI#readme",
   "repository": {
@@ -52,7 +52,6 @@
     "desktop:tauri:check": "cd src-tauri && cargo check",
     "rust:test": "cd rust && cargo test --workspace",
     "rust:lint": "cd rust && cargo fmt --all -- --check && cargo clippy --workspace --all-targets -- -D warnings",
-    "desktop:electron": "electron desktop/electron/main.cjs",
     "package:vsix": "node scripts/build_vsix.mjs",
     "check:screenshot-delta": "node scripts/run_python.mjs scripts/check_screenshot_pixel_delta.py",
     "release:evidence": "node scripts/capture_release_evidence.mjs && node scripts/prune_release_evidence.mjs && npm run check:screenshot-delta",
@@ -124,7 +123,6 @@
     "!src-tauri/gen/**",
     "!src-tauri/target/",
     "!src-tauri/target/**",
-    "desktop/electron/",
     "docs/*.md",
     "!docs/assets/",
     "!docs/images/"
@@ -142,6 +140,7 @@
     "@testing-library/react": "^16.3.2",
     "@testing-library/user-event": "^14.6.1",
     "@types/cytoscape": "^3.21.9",
+    "@types/node": "24.13.2",
     "@types/react": "^19.2.17",
     "@types/react-dom": "^19.2.3",
     "@vitejs/plugin-react": "^6.0.2",
@@ -150,7 +149,6 @@
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
     "cytoscape": "^3.34.0",
-    "electron": "^42.4.0",
     "jsdom": "^29.1.1",
     "lucide-react": "^1.17.0",
     "openapi-fetch": "^0.17.0",

package/scripts/bump_version.py

@@ -25,7 +25,20 @@ REPO = Path(__file__).resolve().parents[1]
 # it per crate — src-tauri's too, since 11.4.0, because the desktop shell now
 # depends on lattice-host by path — and a lockfile left behind is a file the
 # next `cargo build` silently rewrites underneath a tagged release.
-RUST_CRATES = ("lattice-core", "lattice-host", "lattice-retrieval")
+#
+# 11.5.2: this tuple listed only the three Phase-1 crates, so every bump since
+# 11.5.0 left `lattice-agent`, `lattice-ingest` and `lattice-jobs` at the
+# previous version in both lockfiles — and the first `cargo` invocation of the
+# test suite rewrote them, dirtying the tree mid-release. Every workspace
+# member belongs here.
+RUST_CRATES = (
+    "lattice-agent",
+    "lattice-core",
+    "lattice-host",
+    "lattice-ingest",
+    "lattice-jobs",
+    "lattice-retrieval",
+)
 RUST_LOCKFILES = ("rust/Cargo.lock", "src-tauri/Cargo.lock")
 
 # (path, kind, pattern) — pattern groups: (prefix, version)

package/scripts/check_current_release_docs.mjs

@@ -6,7 +6,7 @@ const root = process.cwd();
 const pkg = JSON.parse(readFileSync(path.join(root, "package.json"), "utf8"));
 const version = pkg.version;
 const releaseDir = `output/release/v${version}`;
-const releaseTheme = "Rust Full Loop";
+const releaseTheme = "Tight Ship";
 const title = `${version} — ${releaseTheme}`;
 const escapedVersion = version.replaceAll(".", "\\.");
 

package/scripts/check_legacy_debt.mjs

@@ -31,7 +31,7 @@ const REMOVED_MODULES = [
 ];
 // Trees that must not import removed shims. static/app and node_modules are
 // build output; src-tauri/target is compiler output.
-const SOURCE_TREES = ["latticeai", "lattice_brain", "tests", "scripts", "bin", "desktop/electron"];
+const SOURCE_TREES = ["latticeai", "lattice_brain", "tests", "scripts", "bin"];
 
 const failures = [];
 

package/scripts/generate_agent_loop_fixtures.py

@@ -90,6 +90,11 @@ from latticeai.core.agent_helpers import (  # noqa: E402
     normalize_plan,
     requirement_coverage,
 )
+from latticeai.core.agent_profiles import (  # noqa: E402
+    COMPACT_MAX_PARAMS_B,
+    model_size_b,
+    profile_for_model,
+)
 from latticeai.core.agent_trace import LoopTrace  # noqa: E402
 from latticeai.core.file_generation import (  # noqa: E402
     infer_file_target,
@@ -107,6 +112,7 @@ from latticeai.core.tool_registry import (  # noqa: E402
     TOOL_GOVERNANCE,
     TOOL_GOVERNANCE_DEFAULT,
 )
+from latticeai.tools.documents import document_output_target  # noqa: E402
 
 FIXTURE_DIR = REPO_ROOT / "rust" / "fixtures" / "agent_loop"
 GOLDEN_DIR = FIXTURE_DIR / "golden"
@@ -260,6 +266,59 @@ INFERENCE_MESSAGES: List[str] = [
     "웹사이트 css js 만들어줘", "마크다운 파일 작성해줘", "yaml 만들어줘",
 ]
 
+#: ``(tool_name, filename)`` pairs for the document-target resolver. Chosen for
+#: the branches they reach, not for realism: a tool that is not a document
+#: creator, each of the four that are, a name that already carries its suffix,
+#: one that carries the wrong one, a path that must be reduced to its basename,
+#: characters the sanitizer replaces, and the empty names that fall back to
+#: ``artifact<suffix>``. The Rust port takes the basename with its own
+#: ``path_name`` and has its own empty-name fallback, so those two are exactly
+#: where the two implementations could disagree unnoticed.
+DOCUMENT_TARGET_CASES: List[Dict[str, str]] = [
+    {"tool": "write_file", "filename": "notes.md"},
+    {"tool": "create_docx", "filename": "report.docx"},
+    {"tool": "create_docx", "filename": "report"},
+    {"tool": "create_docx", "filename": "report.pdf"},
+    {"tool": "create_xlsx", "filename": "budget.xlsx"},
+    {"tool": "create_pptx", "filename": "deck"},
+    {"tool": "create_pdf", "filename": "invoice"},
+    {"tool": "create_pdf", "filename": "sub/dir/invoice.pdf"},
+    {"tool": "create_pdf", "filename": "../../escape.pdf"},
+    {"tool": "create_docx", "filename": "회의 기록.docx"},
+    {"tool": "create_docx", "filename": "a/b*c?d.docx"},
+    {"tool": "create_docx", "filename": ""},
+    {"tool": "create_pptx", "filename": "   "},
+    {"tool": "create_xlsx", "filename": "REPORT.XLSX"},
+    {"tool": "create_pdf", "filename": ".pdf"},
+    {"tool": "unknown_tool", "filename": "x.docx"},
+]
+
+#: Model ids for the profile dial. The interesting ones are the quantization
+#: suffixes (``4bit`` is not a parameter count), the multi-size ids where the
+#: *smallest* wins, and the boundary at ``COMPACT_MAX_PARAMS_B`` itself.
+PROFILE_MODEL_IDS: List[str] = [
+    "mlx-community/gemma-4-12B-it-4bit",
+    "qwen2.5-1.5b",
+    "llama-3.2-3B",
+    "mlx-community/Llama-3.2-3B-Instruct-4bit",
+    "phi-4-mini-3.8b-8bit",
+    "some-model-4b",
+    "some-model-4.0b",
+    "some-model-4.1b",
+    "gpt-4o",
+    "claude-sonnet",
+    "",
+    "   ",
+    "model-8bit",
+    "abc123b",
+    "7b-and-1.5b-mixed",
+    "Model-70B-Instruct",
+]
+
+#: ``LATTICEAI_AGENT_PROFILE`` values, including the two that must fall through
+#: to the size heuristic rather than failing the run.
+PROFILE_OVERRIDES: List[str] = ["", "standard", "compact", "COMPACT", "nonsense"]
+
 #: Transcripts the artifact/coverage helpers are asked about.
 TRANSCRIPT_CASES: Dict[str, Dict[str, Any]] = {
     "empty": {"message": "todo 앱 html css js 만들어줘", "transcript": []},
@@ -382,6 +441,31 @@ def helper_rows() -> Dict[str, Any]:
         {"input": case, "kept": filter_learnings(case)} for case in LEARNING_CASES
     ]
 
+    documents = [
+        {**case, "target": document_output_target(case["tool"], case["filename"])}
+        for case in DOCUMENT_TARGET_CASES
+    ]
+
+    # ``env`` is passed explicitly: the Rust twin reads the ambient process
+    # environment, and a golden that inherited this machine's would be a
+    # machine-specific value in a committed fixture.
+    profiles = []
+    for override in PROFILE_OVERRIDES:
+        env = {"LATTICEAI_AGENT_PROFILE": override} if override else {}
+        for model_id in PROFILE_MODEL_IDS:
+            profiles.append({
+                "override": override,
+                "model_id": model_id,
+                "size_b": model_size_b(model_id),
+                "profile": profile_for_model(model_id, env=env).__dict__,
+            })
+    profiles.append({
+        "override": "",
+        "model_id": None,
+        "size_b": model_size_b(""),
+        "profile": profile_for_model(None, env={}).__dict__,
+    })
+
     return normalize({
         "schema": SCHEMA,
         "extract_action_details": actions,
@@ -390,6 +474,8 @@ def helper_rows() -> Dict[str, Any]:
         "transcript_helpers": transcripts,
         "truncate_strings": truncated,
         "filter_learnings": learnings,
+        "document_targets": documents,
+        "agent_profiles": profiles,
         "budgets": {
             "phase": PhaseBudgets().__dict__,
             "transcript": TranscriptBudget().__dict__,
@@ -858,6 +944,7 @@ def manifest_payload() -> Dict[str, Any]:
             "transcript_budget": TranscriptBudget().__dict__,
             "max_state_history": 200,
             "max_retry": 3,
+            "compact_max_params_b": COMPACT_MAX_PARAMS_B,
         },
     }
 

package/scripts/generate_rust_parity_fixtures.py

@@ -50,6 +50,7 @@ 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"
@@ -324,23 +325,6 @@ QUERIES: List[Dict[str, Any]] = [
 
 #: 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": [
@@ -462,21 +446,7 @@ 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,
 }
@@ -799,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 engines — 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,
@@ -870,7 +778,7 @@ 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,
 }