ltcai 11.5.2 → 11.7.0

package/latticeai/services/architecture_readiness.py

@@ -1,10 +1,15 @@
 """Machine-checkable architecture readiness gates for release work.
 
-The current release keeps the major architecture priorities under an explicit release
-contract while product maturity work reduces visible beta seams. AgentRuntime, ToolRegistry,
-central Config, decomposed server runtime, and Knowledge Graph stabilization
-must remain discoverable, ordered, and backed by tests before the release can be
-called complete.
+The current release keeps the major architecture priorities under an explicit
+release contract. Agent permission gates, ToolRegistry, central Config, the
+worker-only composition root, and the compute-side Knowledge Graph helpers
+must remain discoverable, ordered, and backed by tests.
+
+v11.6.0 retargeted every symbol probe at the worker-only tree: the product
+HTTP surface, the Python agent loop, the graph writer and the orchestration
+runtimes now live in Rust. Assertions were not deleted — their paths and
+symbols now name the modules that still own those concerns in Python, or the
+worker seam that is the Python half of a native owner.
 """
 
 from __future__ import annotations
@@ -14,9 +19,7 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Any, Dict, List
 
-from latticeai.core.legacy_compatibility import legacy_shim_report
-
-ARCHITECTURE_VERSION_TARGET = "11.5.2"
+ARCHITECTURE_VERSION_TARGET = "11.7.0"
 
 PREFERRED_REFACTORING_ORDER = [
     "agent-runtime",
@@ -75,6 +78,41 @@ def _forbidden_patterns(root: Path, relative_path: str, patterns: List[str]) ->
     return [pattern for pattern in patterns if pattern in source]
 
 
+def legacy_shim_report(root: Path | None = None) -> Dict[str, Any]:
+    """Sunset report for the root shim layer.
+
+    ``latticeai.core.legacy_compatibility`` was deleted with the product
+    server. The remaining fact this gate still has to prove is: no root
+    ``*.py`` is left, including ``server.py``.
+    """
+    if root is None:
+        root = Path(__file__).resolve().parents[2]
+    lingering = sorted(path.name for path in root.glob("*.py"))
+    removed = [
+        "ltcai_cli.py",
+        "auto_setup.py",
+        "setup_wizard.py",
+        "mcp_registry.py",
+        "kg_schema.py",
+        "knowledge_graph.py",
+        "knowledge_graph_api.py",
+        "local_knowledge_api.py",
+        "llm_router.py",
+        "p_reinforce.py",
+        "telegram_bot.py",
+        "tools/",
+        "server.py",
+    ]
+    return {
+        "status": "managed" if not lingering else "incomplete",
+        "remaining_count": len(lingering),
+        "shims": [],
+        "removed": [{"path": path} for path in removed],
+        "missing": [],
+        "lingering": lingering,
+    }
+
+
 def architecture_readiness(root: Path | None = None) -> Dict[str, Any]:
     if root is None:
         root = Path(__file__).resolve().parents[2]
@@ -118,13 +156,14 @@ def architecture_readiness(root: Path | None = None) -> Dict[str, Any]:
             ["from fastapi import HTTPException", "raise HTTPException"],
         )
     )
-    # v11.3.0: the single-agent loop is a package. The compatibility alias
-    # could reappear in any of its submodules, so every file in the package is
-    # scanned — checking only __init__.py would leave the gate blind one
-    # directory down.
+    # The Python agent loop package is gone. The compatibility alias is now
+    # scanned on the two Python files that still talk about permission mode.
     agent_alias_forbidden = [
         finding
-        for relative_path in _package_sources(root, "latticeai/core/agent")
+        for relative_path in (
+            "latticeai/core/agent_permission.py",
+            "latticeai/api/agent_worker_seam.py",
+        )
         for finding in _forbidden_patterns(
             root,
             relative_path,
@@ -137,13 +176,13 @@ def architecture_readiness(root: Path | None = None) -> Dict[str, Any]:
             id="agent-runtime",
             title="AgentRuntime boundary",
             status="complete" if (
-                _symbol_exists("lattice_brain.runtime.agent_runtime.AgentRuntime")
+                _symbol_exists("latticeai.core.agent_permission.block_reason_for_tool")
                 and not agent_alias_forbidden
             ) else "incomplete",
             evidence=[
-                "lattice_brain.runtime.agent_runtime.AgentRuntime",
-                "latticeai.api.agents.create_agents_router(agent_runtime=...)",
-                "tests/unit/test_agent_runtime_service.py",
+                "latticeai.core.agent_permission.block_reason_for_tool",
+                "latticeai.api.agent_worker_seam.create_agent_worker_seam_router",
+                "tests/unit/test_agent_worker_seam.py",
             ],
         ),
         ArchitectureGate(
@@ -167,7 +206,7 @@ def architecture_readiness(root: Path | None = None) -> Dict[str, Any]:
             evidence=[
                 "latticeai.core.config.Config.from_env",
                 "latticeai.runtime.config_runtime.ConfigRuntime",
-                "tests/unit/test_config.py",
+                "tests/unit/test_runtime_context.py",
             ],
         ),
         ArchitectureGate(
@@ -179,15 +218,15 @@ def architecture_readiness(root: Path | None = None) -> Dict[str, Any]:
                     for symbol in [
                         "latticeai.runtime.config_runtime.ConfigRuntime",
                         "latticeai.runtime.security_runtime.SecurityRuntime",
-                        "latticeai.runtime.brain_runtime.BrainRuntime",
-                        "latticeai.runtime.model_wiring.ModelRuntime",
-                        "latticeai.runtime.router_registration.RouterBundle",
+                        "latticeai.runtime.runtime_context.RuntimeContext",
+                        "latticeai.worker_app.create_worker_app",
+                        "latticeai.app_factory.build_context",
                     ]
                 )
                 and not factory_forbidden
             ) else "incomplete",
             evidence=[
-                "latticeai.app_factory.create_app composition root",
+                "latticeai.worker_app.create_worker_app composition root",
                 "latticeai.api.* domain routers",
                 "latticeai.runtime.* runtime contexts",
             ],
@@ -195,11 +234,11 @@ def architecture_readiness(root: Path | None = None) -> Dict[str, Any]:
         ArchitectureGate(
             id="kg-hardening",
             title="Knowledge Graph stabilization",
-            status="complete" if _symbol_exists("lattice_brain.graph.store.KnowledgeGraphStore") else "incomplete",
+            status="complete" if _symbol_exists("lattice_brain.embeddings.LocalEmbeddingModel") else "incomplete",
             evidence=[
-                "lattice_brain.graph.store.KnowledgeGraphStore",
-                "lattice_brain.portability.KGPortabilityService",
-                "tests/unit/test_kg_portability.py",
+                "lattice_brain.embeddings.LocalEmbeddingModel",
+                "lattice_brain.graph._kg_common.extraction",
+                "tests/unit/test_kg_common_exports.py",
             ],
         ),
         ArchitectureGate(
@@ -217,8 +256,8 @@ def architecture_readiness(root: Path | None = None) -> Dict[str, Any]:
             title="Legacy shim sunset plan",
             status="complete" if shim_report["status"] == "managed" else "incomplete",
             evidence=[
-                "latticeai.core.legacy_compatibility.legacy_shim_report",
-                "docs/LEGACY_COMPATIBILITY.md",
+                "latticeai.services.architecture_readiness.legacy_shim_report",
+                "scripts/check_legacy_debt.mjs",
                 "tests/unit/test_legacy_root_shims.py",
             ],
         ),
@@ -228,17 +267,17 @@ def architecture_readiness(root: Path | None = None) -> Dict[str, Any]:
             status="complete" if all(
                 _symbol_exists(s)
                 for s in [
-                    "lattice_brain.runtime.multi_agent.MultiAgentOrchestrator",
-                    "lattice_brain.workflow.WorkflowEngine",
-                    "latticeai.services.run_executor.RunExecutor",
+                    "latticeai.services.tool_dispatch.ToolDispatchService",
+                    "latticeai.tools.execute_tool",
+                    "latticeai.api.worker_compute.create_worker_compute_router",
                 ]
             ) else "incomplete",
             evidence=[
-                "lattice_brain.runtime.multi_agent.MultiAgentOrchestrator",
-                "lattice_brain.workflow.WorkflowEngine",
-                "latticeai.services.run_executor.RunExecutor",
-                "tests/unit/test_agent_platform_maturity.py",
-                "tests/unit/test_t7_async_run_executor.py",
+                "latticeai.services.tool_dispatch.ToolDispatchService",
+                "latticeai.tools.execute_tool",
+                "latticeai.api.worker_compute.create_worker_compute_router",
+                "tests/unit/test_tool_registry.py",
+                "tests/unit/test_worker_compute.py",
             ],
         ),
     ]
@@ -252,13 +291,13 @@ def architecture_readiness(root: Path | None = None) -> Dict[str, Any]:
         "refactoring_order": list(PREFERRED_REFACTORING_ORDER),
         "boundaries": {
             "agent-runtime": {
-                "owner": "lattice_brain.runtime.agent_runtime.AgentRuntime",
-                "surface": "/agents",
-                "status": "facade",
+                "owner": "latticeai.core.agent_permission.block_reason_for_tool",
+                "surface": "/agent/llm + /agent/tool",
+                "status": "worker-seam",
             },
             "tool-registry": {
                 "owner": "latticeai.core.tool_registry.ToolRegistry",
-                "surface": "/tools",
+                "surface": "/agent/tool",
                 "status": "registry",
             },
             "config-centralization": {
@@ -267,9 +306,9 @@ def architecture_readiness(root: Path | None = None) -> Dict[str, Any]:
                 "status": "typed-config",
             },
             "kg-hardening": {
-                "owner": "lattice_brain.graph.store.KnowledgeGraphStore",
-                "strategy": "additive reprojection with legacy read compatibility",
-                "rollback": "portable export/import and non-destructive migration paths",
+                "owner": "lattice_brain.embeddings.LocalEmbeddingModel",
+                "strategy": "compute-only embedder and _kg_common helpers; writes are native",
+                "rollback": "committed rust/fixtures goldens; Python generators frozen at fc65e60",
             },
         },
         "ordered_gate_ids": ordered_gate_ids,

package/latticeai/services/model_runtime/__init__.py

@@ -8,8 +8,8 @@ Split into cohesive submodules in v11.3.0 (no behaviour change): ``state`` (the
 immutable ``ModelRuntimeState`` and the consent gates), ``engines`` (engine
 wrappers + the LM Studio client), ``download`` (Hugging Face readiness and
 fetch), ``status`` (``engine_status`` / ``runtime_features`` / ``install_engine``),
-``loading`` (identity resolution and the load entrypoints), ``cloud`` (cloud key
-verification) and ``service`` (the bound ``ModelRuntimeService``). This module
+``loading`` (identity resolution and the load entrypoints) and ``service`` (the
+bound ``ModelRuntimeService``). This module
 re-exports every name the single file exposed, so
 ``latticeai.services.model_runtime.X`` keeps working — including the private
 names ``model_loading._get_model_runtime_deps`` imports.
@@ -69,15 +69,6 @@ from latticeai.services.model_catalog import (
     filter_lower_family_versions as filter_lower_family_versions,
 )
 from latticeai.services.model_errors import ModelRuntimeError as ModelRuntimeError
-from latticeai.services.model_runtime.cloud import (
-    CLOUD_VERIFY_TTL_SECONDS as CLOUD_VERIFY_TTL_SECONDS,
-)
-from latticeai.services.model_runtime.cloud import (
-    _probe_cloud_model as _probe_cloud_model,
-)
-from latticeai.services.model_runtime.cloud import (
-    verify_cloud_models as verify_cloud_models,
-)
 from latticeai.services.model_runtime.download import (
     download_hf_model as download_hf_model,
 )

package/latticeai/services/model_runtime/service.py

@@ -12,7 +12,6 @@ from __future__ import annotations
 from dataclasses import dataclass, field
 from typing import Any, AsyncIterator, Dict, List, Optional
 
-from latticeai.services.model_runtime.cloud import verify_cloud_models
 from latticeai.services.model_runtime.loading import (
     prepare_and_load_model,
     prepare_and_load_model_stream,
@@ -21,11 +20,7 @@ from latticeai.services.model_runtime.state import (
     ModelRuntimeState,
     create_model_runtime_state,
 )
-from latticeai.services.model_runtime.status import (
-    engine_status,
-    install_engine,
-    runtime_features,
-)
+from latticeai.services.model_runtime.status import engine_status, runtime_features
 
 
 def configure_model_runtime(**deps: Any) -> "ModelRuntimeService":
@@ -49,6 +44,9 @@ class ModelRuntimeService:
     """
 
     state: ModelRuntimeState
+    #: Engine probes cache their cloud-provider answers here. It is per-service
+    #: rather than process-wide so a second application starts with an empty
+    #: cache instead of inheriting probe results it never ran.
     _cloud_verify_cache: Dict[str, Dict[str, Any]] = field(default_factory=dict)
 
     def runtime_features(self) -> Dict[str, Any]:
@@ -60,28 +58,6 @@ class ModelRuntimeService:
             cloud_verify_cache=self._cloud_verify_cache,
         )
 
-    def install_engine(
-        self,
-        engine: str,
-        confirmation_token: Optional[str] = None,
-    ) -> Dict[str, Any]:
-        return install_engine(
-            engine,
-            confirmation_token=confirmation_token,
-            state=self.state,
-        )
-
-    async def verify_cloud_models(
-        self,
-        force: bool = False,
-        provider_filter: Optional[str] = None,
-    ) -> Dict[str, Dict[str, Any]]:
-        return await verify_cloud_models(
-            force=force,
-            provider_filter=provider_filter,
-            state=self.state,
-            cache=self._cloud_verify_cache,
-        )
 
     async def prepare_and_load_model(
         self,

package/latticeai/services/p_reinforce.py

@@ -1,23 +1,16 @@
+"""Where the knowledge garden lives, and what its folders mean.
+
+``PReinforceGardener`` — vault import, note creation, brain-backed context —
+was the writing half, and writing the vault is ``lattice-retrieval``'s
+(``/garden/*``) since v11.6.0. The two constants stay because the worker's
+read-only vault tools (``knowledge_search``, ``knowledge_tree``,
+``obsidian_search``, ``obsidian_tree``) resolve their root through them, and a
+second definition of "where the vault is" is exactly how a search and a save
+end up in different directories.
 """
-P-Reinforce Knowledge Gardener — notes capture with a brain-backed memory.
 
-v4 (T4.3 garden absorption): the markdown vault is no longer a second brain.
-The vault stays as the user-owned, Obsidian-compatible *mirror* (capability
-preserved), but the Knowledge Graph is authoritative: notes created through
-the API are ingested through the unified pipeline (provenance + hooks), the
-existing vault is imported idempotently, and chat context comes from brain
-queries instead of an O(n) vault scan per message.
-"""
-
-import logging
 import os
-import re
-import shutil
-from datetime import datetime
 from pathlib import Path
-from typing import Any, Optional
-
-from latticeai.core.quiet import quiet
 
 BRAIN_DIR = Path(
     os.getenv("LATTICEAI_OBSIDIAN_VAULT_DIR")
@@ -34,248 +27,4 @@ STRUCTURE = {
 }
 
 
-class PReinforceGardener:
-    def __init__(self, ingestion_pipeline: Any = None, knowledge_graph: Any = None):
-        self._pipeline = ingestion_pipeline
-        self._kg = knowledge_graph
-        self._ensure_structure()
-
-    def _ensure_structure(self):
-        for folder in STRUCTURE:
-            (BRAIN_DIR / folder).mkdir(parents=True, exist_ok=True)
-        # 인덱스 파일
-        index_path = BRAIN_DIR / "INDEX.md"
-        if not index_path.exists():
-            index_path.write_text(self._render_index())
-
-    def _render_index(self) -> str:
-        lines = ["# 🧠 Lattice AI Brain — P-Reinforce Index\n"]
-        lines.append(f"*Generated: {datetime.now().strftime('%Y-%m-%d %H:%M')}*\n")
-        lines.append("\nThis folder is an Obsidian-compatible Markdown vault.\n")
-        lines.append("\nThe Knowledge Graph is the authoritative store; this vault is the\nuser-owned markdown mirror of garden notes.\n")
-        for folder, desc in STRUCTURE.items():
-            lines.append(f"## [{folder}](./{folder}/)\n_{desc}_\n")
-        lines.append("## Connector Status\n")
-        lines.append(f"- OCR engine: `{'tesseract' if shutil.which('tesseract') else 'not installed'}`\n")
-        return "\n".join(lines)
-
-    # ── Classify ──────────────────────────────────────────────────────────────
-
-    def _classify(self, text: str) -> str:
-        """간단한 규칙 기반 분류 (LLM 없이도 동작)"""
-        text_lower = text.lower()
-
-        code_signals = ["def ", "class ", "import ", "```", "function ", "const ", "let ", "var "]
-        if any(s in text for s in code_signals):
-            return "20_Skills"
-
-        wiki_signals = ["개념", "원리", "이란", "what is", "how does", "definition", "explanation"]
-        if any(s in text_lower for s in wiki_signals):
-            return "10_Wiki"
-
-        project_signals = ["project", "프로젝트", "todo", "task", "작업", "기능", "feature"]
-        if any(s in text_lower for s in project_signals):
-            return "30_Projects"
-
-        return "00_Raw"
-
-    # ── File Naming ───────────────────────────────────────────────────────────
-
-    def _make_filename(self, text: str, folder: str) -> str:
-        # 첫 줄을 제목으로
-        first_line = text.strip().split("\n")[0][:60]
-        # 파일명 안전하게
-        safe = re.sub(r"[^\w\s-]", "", first_line).strip()
-        safe = re.sub(r"\s+", "_", safe)
-        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-        return f"{timestamp}_{safe or 'note'}.md"
-
-    # ── Process ───────────────────────────────────────────────────────────────
-
-    async def process(self, raw_data: str, category: Optional[str] = None) -> dict:
-        folder = category if category in STRUCTURE else self._classify(raw_data)
-        filename = self._make_filename(raw_data, folder)
-        filepath = BRAIN_DIR / folder / filename
-
-        # 마크다운 미러 (사용자 소유 Obsidian 호환 아티팩트)
-        content = self._wrap_markdown(raw_data, folder)
-        filepath.write_text(content, encoding="utf-8")
-
-        # 오늘 로그에도 기록
-        self._append_log(raw_data[:200], folder, filename)
-
-        result = {
-            "status": "saved",
-            "folder": folder,
-            "filename": filename,
-            "path": str(filepath),
-            "classified_as": folder,
-            "description": STRUCTURE[folder],
-        }
-        # 두뇌(Knowledge Graph)가 정식 저장소: 통합 수집 파이프라인으로 ingest.
-        result.update(self._ingest_note(raw_data, source_uri=str(filepath), folder=folder))
-        return result
-
-    def _ingest_note(self, text: str, *, source_uri: str, folder: str, title: Optional[str] = None) -> dict:
-        if self._pipeline is None:
-            return {"graph": "unavailable", "graph_detail": "ingestion pipeline not wired"}
-        try:
-            from lattice_brain.ingestion import IngestionItem
-
-            ingest = self._pipeline.ingest(
-                IngestionItem(
-                    source_type="note",
-                    title=title or text.strip().split("\n")[0][:80],
-                    text=text,
-                    source_uri=source_uri,
-                    metadata={"garden_folder": folder, "pipeline": "p-reinforce"},
-                )
-            )
-            if ingest.status != "ok":
-                return {"graph": ingest.status, "graph_detail": ingest.detail}
-            return {
-                "graph": "ok",
-                "graph_node_id": ingest.node_id,
-                "provenance_id": ingest.provenance_id,
-                "duplicate": ingest.duplicate,
-            }
-        except Exception as exc:
-            logging.warning("garden note ingest failed: %s", exc)
-            return {"graph": "failed", "graph_detail": str(exc)}
-
-    def import_vault(self) -> dict:
-        """Idempotent import of every existing vault note into the brain.
-
-        Content-hash dedup in the store makes re-runs safe; vault files are
-        never modified or deleted. INDEX.md and the daily logs are skipped.
-        """
-        if self._pipeline is None:
-            return {"status": "unavailable", "imported": 0}
-        imported = duplicates = failed = 0
-        for file_path in sorted(BRAIN_DIR.rglob("*.md")):
-            if file_path.name == "INDEX.md" or "40_Log" in file_path.parts:
-                continue
-            try:
-                text = file_path.read_text(encoding="utf-8")
-            except Exception:
-                failed += 1
-                continue
-            folder = file_path.parent.name if file_path.parent != BRAIN_DIR else "00_Raw"
-            outcome = self._ingest_note(
-                text, source_uri=str(file_path), folder=folder, title=file_path.stem
-            )
-            if outcome.get("graph") == "ok":
-                if outcome.get("duplicate"):
-                    duplicates += 1
-                else:
-                    imported += 1
-            else:
-                failed += 1
-        if imported:
-            logging.info("garden: imported %d vault notes into the brain (%d already known)", imported, duplicates)
-        return {"status": "ok", "imported": imported, "duplicates": duplicates, "failed": failed}
-
-    def _wrap_markdown(self, raw: str, folder: str) -> str:
-        now = datetime.now().strftime("%Y-%m-%d %H:%M")
-        first_line = raw.strip().split("\n")[0][:80]
-        lines = [
-            f"# {first_line}",
-            f"\n> 📁 `{folder}` | 🕐 {now} | Lattice AI MLX\n",
-            "---\n",
-            raw,
-            "\n\n---",
-            "*Auto-organized by P-Reinforce Gardener*",
-        ]
-        return "\n".join(lines)
-
-    def _append_log(self, preview: str, folder: str, filename: str):
-        today = datetime.now().strftime("%Y-%m-%d")
-        log_path = BRAIN_DIR / "40_Log" / f"{today}.md"
-        entry = f"\n- [{datetime.now().strftime('%H:%M')}] → `{folder}/{filename}`\n  > {preview[:100]}\n"
-        with open(log_path, "a", encoding="utf-8") as f:
-            if log_path.stat().st_size == 0 if log_path.exists() else True:
-                f.write(f"# 📅 Log — {today}\n")
-            f.write(entry)
-
-    # ── Tree ──────────────────────────────────────────────────────────────────
-
-    def get_tree(self) -> dict:
-        """지식 정원 파일트리 (마크다운 미러 기준)."""
-        folders = []
-        for folder, desc in STRUCTURE.items():
-            folder_path = BRAIN_DIR / folder
-            files = []
-            if folder_path.exists():
-                for file_path in sorted(folder_path.glob("*.md")):
-                    try:
-                        stat = file_path.stat()
-                        files.append({
-                            "name": file_path.name,
-                            "size_bytes": stat.st_size,
-                            "modified_at": datetime.fromtimestamp(stat.st_mtime).isoformat(timespec="seconds"),
-                        })
-                    except OSError:
-                        quiet()
-                        continue
-            folders.append({"name": folder, "description": desc, "files": files, "count": len(files)})
-        return {"root": str(BRAIN_DIR), "folders": folders}
-
-    def get_relevant_context(
-        self,
-        query: str,
-        limit: int = 3,
-        *,
-        allowed_workspaces: Any = None,
-    ) -> str:
-        """질문과 관련된 정원 노트를 두뇌에서 검색해 컨텍스트로 반환.
-
-        v4: 채팅마다 vault 전체를 rglob 하던 O(n) 스캔을 브레인 검색으로
-        대체. 그래프가 없으면(비활성) 기존 파일 스캔으로 정직하게 폴백.
-        """
-        if self._kg is not None:
-            try:
-                scope_kwargs = (
-                    {"allowed_workspaces": allowed_workspaces}
-                    if allowed_workspaces is not None
-                    else {}
-                )
-                matches = self._kg.search(
-                    query,
-                    max(limit * 4, 8),
-                    **scope_kwargs,
-                ).get("matches", [])
-                results = []
-                for match in matches:
-                    meta = match.get("metadata") or {}
-                    if not (meta.get("garden_folder") or meta.get("pipeline") == "p-reinforce"):
-                        continue
-                    title = match.get("title") or "note"
-                    body = match.get("summary") or ""
-                    results.append(f"--- Document: {title} ---\n{body[:800]}")
-                    if len(results) >= limit:
-                        break
-                return "\n\n".join(results)
-            except Exception as exc:
-                logging.debug("garden brain context failed: %s", exc)
-                if allowed_workspaces is not None:
-                    return ""
-        elif allowed_workspaces is not None:
-            return ""
-        return self._scan_vault_context(query, limit)
-
-    def _scan_vault_context(self, query: str, limit: int = 3) -> str:
-        results = []
-        for file_path in BRAIN_DIR.rglob("*.md"):
-            if file_path.name == "INDEX.md" or "40_Log" in str(file_path):
-                continue
-            try:
-                content = file_path.read_text(encoding="utf-8")
-                keywords = [k for k in re.split(r"\s+", query) if len(k) > 1]
-                if any(k.lower() in content.lower() for k in keywords):
-                    results.append(f"--- Document: {file_path.name} ---\n{content[:800]}")
-                    if len(results) >= limit:
-                        break
-            except Exception:
-                quiet()
-                continue
-        return "\n\n".join(results)
+__all__ = ["BRAIN_DIR", "STRUCTURE"]