ltcai 6.1.0 → 6.3.0

package/latticeai/runtime/chat_wiring.py

@@ -0,0 +1,119 @@
+"""Chat and interaction wiring seam for ``latticeai.app_factory``."""
+
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from latticeai.services.router_context import InteractionRouterContext, ToolRouterContext
+
+
+def build_chat_agent_runtime_from_context(
+    *,
+    build_agent_runtime: Any,
+    model_router: Any,
+    execute_tool: Any,
+    recent_chat_context: Any,
+    clear_history: Any,
+    knowledge_save: Any,
+    audit: Any,
+    hooks: Any,
+    brain_memory: Any,
+) -> Any:
+    return build_agent_runtime(
+        model_router=model_router,
+        execute_tool=execute_tool,
+        recent_chat_context=recent_chat_context,
+        clear_history=clear_history,
+        knowledge_save=knowledge_save,
+        audit=audit,
+        hooks=hooks,
+        brain_memory=brain_memory,
+    )
+
+
+def build_interaction_contexts(
+    *,
+    config: Any,
+    ingestion_pipeline: Any,
+    data_dir: Any,
+    static_dir: Any,
+    model_router: Any,
+    require_user: Any,
+    require_admin: Any,
+    get_current_user: Any,
+    clear_history: Any,
+    append_audit_event: Any,
+    enforce_rate_limit: Any,
+    bytes_match_extension: Any,
+    classify_sensitive_message: Any,
+    save_to_history: Any,
+    enable_graph: bool,
+    knowledge_graph: Any,
+    require_graph: Any,
+    local_kg_watcher: Any,
+    load_mcp_installs: Any,
+    recommend_mcps: Any,
+    install_mcp: Any,
+    mcp_public_item: Any,
+    hooks: Any,
+    chat_context: Any,
+    search_service: Any,
+    allowed_workspaces_for: Any,
+    embedding_info: Any,
+    agent_registry: Any,
+    memory_service: Any,
+    platform: Any,
+) -> tuple[ToolRouterContext, InteractionRouterContext]:
+    tool_router_context = ToolRouterContext(
+        config=config,
+        ingestion_pipeline=ingestion_pipeline,
+        data_dir=data_dir,
+        static_dir=static_dir,
+        model_router=model_router,
+        require_user=require_user,
+        require_admin=require_admin,
+        get_current_user=get_current_user,
+        clear_history=clear_history,
+        append_audit_event=append_audit_event,
+        enforce_rate_limit=enforce_rate_limit,
+        bytes_match_extension=bytes_match_extension,
+        classify_sensitive_message=classify_sensitive_message,
+        save_to_history=save_to_history,
+        enable_graph=enable_graph,
+        knowledge_graph=knowledge_graph,
+        require_graph=require_graph,
+        local_kg_watcher=local_kg_watcher,
+        load_mcp_installs=load_mcp_installs,
+        recommend_mcps=recommend_mcps,
+        install_mcp=install_mcp,
+        mcp_public_item=mcp_public_item,
+        hooks=hooks,
+    )
+    interaction_router_context = InteractionRouterContext(
+        chat_context=chat_context,
+        search_service=search_service,
+        allowed_workspaces_for=allowed_workspaces_for,
+        require_user=require_user,
+        embedding_info=embedding_info,
+        tool_context=tool_router_context,
+        hooks=hooks,
+        agent_registry=agent_registry,
+        memory_service=memory_service,
+        platform=platform,
+    )
+    return tool_router_context, interaction_router_context
+
+
+def maybe_build_telegram_chat_mirror(
+    *,
+    enable_telegram: bool,
+    spawn: Any,
+) -> Optional[Any]:
+    if not enable_telegram:
+        return None
+
+    def telegram_chat_mirror(role: str, text: str, source: Optional[str] = None) -> None:
+        from latticeai.integrations.telegram_bot import broadcast_web_chat
+        spawn(broadcast_web_chat(role, text), name="telegram_broadcast")
+
+    return telegram_chat_mirror

package/latticeai/runtime/lifespan_runtime.py

@@ -102,7 +102,7 @@ def build_lifespan_runtime(
         try:
             print(f"🧭 Lattice AI mode: {app_mode}")
             if enable_telegram:
-                from telegram_bot import run_bot
+                from latticeai.integrations.telegram_bot import run_bot
 
                 spawn(run_bot(), name="telegram_bot")
                 print("🚀 Telegram Bot Bridge activated!")

package/latticeai/runtime/model_wiring.py

@@ -0,0 +1,40 @@
+"""Model/runtime wiring seam for ``latticeai.app_factory``."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from latticeai.runtime.platform_services_runtime import build_model_service
+
+
+def configure_model_runtime_from_context(**kwargs: Any) -> None:
+    configure_model_runtime = kwargs.pop("configure_model_runtime")
+    configure_model_runtime(**kwargs)
+
+
+def register_model_runtime_routers(
+    *,
+    app: Any,
+    create_health_router: Any,
+    create_models_router: Any,
+    register_health_and_model_routers: Any,
+    model_router: Any,
+    runtime_features: Any,
+    is_public_mode: bool,
+    **kwargs: Any,
+) -> Any:
+    model_service = build_model_service(
+        model_router=model_router,
+        runtime_features=runtime_features,
+        is_public=is_public_mode,
+    )
+    register_health_and_model_routers(
+        app,
+        create_health_router=create_health_router,
+        model_service=model_service,
+        create_models_router=create_models_router,
+        model_router=model_router,
+        is_public_mode=is_public_mode,
+        **kwargs,
+    )
+    return model_service

package/latticeai/runtime/platform_runtime_wiring.py

@@ -0,0 +1,86 @@
+"""Platform and automation wiring for the application factory.
+
+This module owns the cross-subsystem runtime assembly that used to live inline
+inside ``app_factory._build``.  Keeping it here reduces the app factory's global
+surface without changing router order or the legacy exported runtime names.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Callable, Dict
+
+
+def build_platform_automation_runtime(
+    *,
+    model_router: Any,
+    workspace_store: Any,
+    workspace_service: Any,
+    plugin_registry: Any,
+    get_current_user: Callable[..., Any],
+    workspace_graph: Callable[[], Any],
+    workspace_scope_from_request: Callable[..., Any],
+    get_tool_permission: Callable[..., Any],
+    hooks: Any,
+    agent_registry: Any,
+    data_dir: Any,
+    append_audit_event: Callable[..., Any],
+) -> Dict[str, Any]:
+    """Build platform services, automation services, and hook bindings.
+
+    The returned names intentionally match the historical local variables in
+    ``app_factory._build`` so ``dict(locals())`` continues to expose the legacy
+    ``server_app`` compatibility surface.
+    """
+    from latticeai.runtime.automation_runtime import build_automation_runtime
+    from latticeai.services.platform_runtime import PlatformRuntime
+
+    def _llm_generate_sync(
+        message: str,
+        context: str = "",
+        max_tokens: int = 1024,
+        temperature: float = 0.1,
+    ) -> str:
+        # Synchronous model bridge for the orchestrator's role runner. Safe
+        # because the agents run endpoint executes start() in a worker thread
+        # (asyncio.to_thread), where no event loop is running.
+        import asyncio as _asyncio
+
+        return str(_asyncio.run(model_router.generate(
+            message,
+            context=context,
+            max_tokens=max_tokens,
+            temperature=temperature,
+        )))
+
+    platform = PlatformRuntime(
+        store=workspace_store,
+        workspace_service=workspace_service,
+        plugin_registry=plugin_registry,
+        get_current_user=get_current_user,
+        workspace_graph=workspace_graph,
+        workspace_scope_from_request=workspace_scope_from_request,
+        get_tool_permission=get_tool_permission,
+        hooks=hooks,
+        llm_generate=_llm_generate_sync,
+        llm_available=lambda: bool(getattr(model_router, "current_model_id", None)),
+        agent_registry=agent_registry,
+    )
+
+    automation_runtime = build_automation_runtime(
+        store=workspace_store,
+        platform=platform,
+        data_dir=data_dir,
+        workspace_graph=workspace_graph,
+        append_audit_event=append_audit_event,
+        hooks=hooks,
+    )
+
+    return {
+        "_llm_generate_sync": _llm_generate_sync,
+        "PLATFORM": platform,
+        "_automation_runtime": automation_runtime,
+        "REVIEW_QUEUE": automation_runtime["REVIEW_QUEUE"],
+        "TRIGGER_SERVICE": automation_runtime["TRIGGER_SERVICE"],
+        "AGENT_RUNTIME": automation_runtime["AGENT_RUNTIME"],
+        "RUN_EXECUTOR": automation_runtime["RUN_EXECUTOR"],
+    }

package/latticeai/runtime/review_wiring.py

@@ -0,0 +1,37 @@
+"""Review Center runtime wiring helpers."""
+
+from __future__ import annotations
+
+from typing import Any, Callable, Dict, Optional
+
+
+def build_review_run_now_runner(platform: Any, http_exception: type[Exception]) -> Callable[..., Any]:
+    """Build the Review Center run-now runner used by the API router.
+
+    The runner preserves the public contract: "Run now" previews/regenerates the
+    source workflow, records a fresh run id, and leaves approval status unchanged.
+    """
+
+    def run_review_item(
+        item: Dict[str, Any],
+        *,
+        user_email: Optional[str],
+        scope: Optional[str],
+    ) -> Any:
+        payload = item.get("payload") or {}
+        provenance = item.get("provenance") or {}
+        workflow_id = payload.get("workflow_id") or provenance.get("workflow_id")
+        if not workflow_id:
+            raise http_exception(status_code=409, detail="review item has no workflow to run")
+        return platform.run_workflow_by_id(
+            workflow_id,
+            user_email,
+            scope,
+            with_agent=False,
+            inputs={"__review_item__": item.get("id")},
+        )
+
+    return run_review_item
+
+
+__all__ = ["build_review_run_now_runner"]

package/latticeai/runtime/router_registration.py

@@ -10,6 +10,8 @@ from __future__ import annotations
 
 from typing import Any
 
+from latticeai.services.router_context import InteractionRouterContext
+
 
 def build_static_routes_bundle(
     *,
@@ -412,45 +414,61 @@ def register_health_and_model_routers(
 def register_interaction_routers(
     app: Any,
     *,
+    interaction_context: InteractionRouterContext | None = None,
     create_chat_router: Any,
-    context: Any,
+    context: Any = None,
     create_search_router: Any,
-    search_service: Any,
-    allowed_workspaces_for: Any,
-    require_user: Any,
-    embedding_info: Any,
+    search_service: Any = None,
+    allowed_workspaces_for: Any = None,
+    require_user: Any = None,
+    embedding_info: Any = None,
     create_tools_router: Any,
-    ingestion_pipeline: Any,
-    config: Any,
-    data_dir: Any,
-    static_dir: Any,
-    model_router: Any,
-    require_admin: Any,
-    get_current_user: Any,
-    clear_history: Any,
-    append_audit_event: Any,
-    enforce_rate_limit: Any,
-    bytes_match_extension: Any,
-    classify_sensitive_message: Any,
-    save_to_history: Any,
-    enable_graph: bool,
-    knowledge_graph: Any,
-    require_graph: Any,
-    local_kg_watcher: Any,
-    load_mcp_installs: Any,
-    recommend_mcps: Any,
-    install_mcp: Any,
-    mcp_public_item: Any,
-    hooks: Any,
+    ingestion_pipeline: Any = None,
+    config: Any = None,
+    data_dir: Any = None,
+    static_dir: Any = None,
+    model_router: Any = None,
+    require_admin: Any = None,
+    get_current_user: Any = None,
+    clear_history: Any = None,
+    append_audit_event: Any = None,
+    enforce_rate_limit: Any = None,
+    bytes_match_extension: Any = None,
+    classify_sensitive_message: Any = None,
+    save_to_history: Any = None,
+    enable_graph: bool | None = None,
+    knowledge_graph: Any = None,
+    require_graph: Any = None,
+    local_kg_watcher: Any = None,
+    load_mcp_installs: Any = None,
+    recommend_mcps: Any = None,
+    install_mcp: Any = None,
+    mcp_public_item: Any = None,
+    hooks: Any = None,
     create_hooks_router: Any,
     create_agent_registry_router: Any,
-    agent_registry: Any,
+    agent_registry: Any = None,
     create_memory_router: Any,
-    memory_service: Any,
-    platform: Any,
+    memory_service: Any = None,
+    platform: Any = None,
 ) -> tuple[Any, ...]:
     """Register chat/search/tools/hooks/registry/memory routes in order."""
 
+    tool_context = None
+    if interaction_context is not None:
+        context = interaction_context.chat_context
+        search_service = interaction_context.search_service
+        allowed_workspaces_for = interaction_context.allowed_workspaces_for
+        require_user = interaction_context.require_user
+        embedding_info = interaction_context.embedding_info
+        tool_context = interaction_context.tool_context
+        get_current_user = tool_context.get_current_user
+        append_audit_event = tool_context.append_audit_event
+        hooks = interaction_context.hooks
+        agent_registry = interaction_context.agent_registry
+        memory_service = interaction_context.memory_service
+        platform = interaction_context.platform
+
     return register_routers(
         app,
         create_chat_router(context),
@@ -461,6 +479,7 @@ def register_interaction_routers(
             embedding_info=embedding_info,
         ),
         create_tools_router(
+            tool_context=tool_context,
             ingestion_pipeline=ingestion_pipeline,
             config=config,
             data_dir=data_dir,

package/latticeai/runtime/tail_wiring.py

@@ -0,0 +1,21 @@
+"""Review, browser, portability, network, garden, and setup tail wiring."""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def register_tail_runtime_routers(
+    *,
+    app: Any,
+    create_review_queue_router: Any,
+    register_review_and_brain_tail_routers: Any,
+    build_brain_network: Any,
+    **kwargs: Any,
+) -> Any:
+    return register_review_and_brain_tail_routers(
+        app,
+        create_review_queue_router=create_review_queue_router,
+        build_brain_network=build_brain_network,
+        **kwargs,
+    )

package/latticeai/services/p_reinforce.py

@@ -0,0 +1,258 @@
+"""
+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
+
+BRAIN_DIR = Path(
+    os.getenv("LATTICEAI_OBSIDIAN_VAULT_DIR")
+    or os.getenv("LATTICEAI_BRAIN_DIR")
+    or Path.home() / ".ltcai-brain"
+)
+
+STRUCTURE = {
+    "10_Wiki":   "검증된 지식, 개념 설명, 레퍼런스",
+    "00_Raw":    "정제되지 않은 원시 데이터, 아이디어 메모",
+    "20_Skills": "재사용 가능한 코드 스니펫, 프롬프트, 워크플로",
+    "30_Projects": "프로젝트별 컨텍스트, 진행 상황",
+    "40_Log":    "날짜별 작업 로그",
+}
+
+
+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:
+                        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) -> str:
+        """질문과 관련된 정원 노트를 두뇌에서 검색해 컨텍스트로 반환.
+
+        v4: 채팅마다 vault 전체를 rglob 하던 O(n) 스캔을 브레인 검색으로
+        대체. 그래프가 없으면(비활성) 기존 파일 스캔으로 정직하게 폴백.
+        """
+        if self._kg is not None:
+            try:
+                matches = self._kg.search(query, max(limit * 4, 8)).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, falling back to vault scan: %s", exc)
+        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:
+                continue
+        return "\n\n".join(results)