ltcai 9.5.0 → 9.7.0

package/latticeai/runtime/router_registration.py

@@ -604,6 +604,7 @@ def register_review_and_brain_tail_routers(
     gardener: Any,
     create_setup_router: Any,
     model_router: Any,
+    change_proposals: Any = None,
 ) -> Any:
     """Register the final review/browser/brain tail routes in legacy order."""
 
@@ -616,6 +617,7 @@ def register_review_and_brain_tail_routers(
             gate_write=gate_write,
             run_review_item=run_review_item,
             append_audit_event=append_audit_event,
+            change_proposals=change_proposals,
         ),
         create_browser_router(
             pipeline=ingestion_pipeline,

package/latticeai/services/architecture_readiness.py

@@ -17,7 +17,7 @@ from typing import Any, Dict, List
 from latticeai.core.legacy_compatibility import legacy_shim_report
 
 
-ARCHITECTURE_VERSION_TARGET = "9.5.0"
+ARCHITECTURE_VERSION_TARGET = "9.7.0"
 
 PREFERRED_REFACTORING_ORDER = [
     "agent-runtime",

package/latticeai/services/brain_intelligence.py

@@ -65,6 +65,23 @@ class BrainIntelligenceService:
         self._enable_graph = bool(enable_graph and knowledge_graph is not None)
         self._memory_quality = MemoryQualityManager()
         self._edge_quality = GraphEdgeQualityManager()
+        self._proactive_brain: Any = None
+
+    def _proactive(self) -> Any:
+        """Lazy graph-layer ProactiveBrain over the injected store (or None)."""
+        if not self._enable_graph:
+            return None
+        if self._proactive_brain is None:
+            try:
+                from lattice_brain.graph.proactive import ProactiveBrain
+
+                self._proactive_brain = ProactiveBrain(
+                    self._kg, sample_limit=_GRAPH_SAMPLE_LIMIT
+                )
+            except Exception:
+                LOGGER.exception("proactive brain initialization failed")
+                return None
+        return self._proactive_brain
 
     # ── shared graph sampling ─────────────────────────────────────────────
 
@@ -302,6 +319,56 @@ class BrainIntelligenceService:
             "generated_at": _now(),
         }
 
+    # ── graph-layer proactive quality (v9.6.x) ───────────────────────────
+
+    def graph_duplicates(
+        self, *, user_email: Optional[str] = None, workspace_id: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """Duplicate graph nodes (exact groups + near pairs) — read only."""
+        proactive = self._proactive()
+        if proactive is None:
+            return {
+                "available": False,
+                "exact_groups": [],
+                "near_pairs": [],
+                "exact_duplicate_nodes": 0,
+                "nodes_scanned": 0,
+                "generated_at": _now(),
+            }
+        try:
+            result = dict(proactive.find_duplicates(workspace_id=workspace_id))
+        except Exception as exc:
+            LOGGER.exception("graph duplicates scan failed")
+            return {
+                "available": False,
+                "error": str(exc),
+                "exact_groups": [],
+                "near_pairs": [],
+                "exact_duplicate_nodes": 0,
+                "nodes_scanned": 0,
+                "generated_at": _now(),
+            }
+        result["available"] = True
+        result["generated_at"] = _now()
+        return result
+
+    def quality_report(
+        self, *, user_email: Optional[str] = None, workspace_id: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """Combined graph quality report: duplicates, contradictions, stale
+        nodes, edge quality — one workspace-scoped graph sample."""
+        proactive = self._proactive()
+        if proactive is None:
+            return {"available": False, "generated_at": _now()}
+        try:
+            result = dict(proactive.quality_report(workspace_id=workspace_id))
+        except Exception as exc:
+            LOGGER.exception("graph quality report failed")
+            return {"available": False, "error": str(exc), "generated_at": _now()}
+        result["available"] = True
+        result["generated_at"] = _now()
+        return result
+
     # ── contradictions ───────────────────────────────────────────────────
 
     def contradictions(
@@ -365,7 +432,21 @@ class BrainIntelligenceService:
                     "signal": "contradicts_edge",
                 })
 
-        items = conflicts + temporal_items + edge_items
+        # v9.6.x additive: graph-layer node-content contradictions (proactive
+        # detector over node title/summary), on top of the memory + edge scans.
+        graph_pair_items: List[Dict[str, Any]] = []
+        proactive = self._proactive()
+        if proactive is not None:
+            try:
+                graph_result = proactive.detect_contradictions(workspace_id=workspace_id)
+                graph_pair_items = [
+                    {"kind": "graph_node_pair", **pair}
+                    for pair in graph_result.get("node_pairs") or []
+                ]
+            except Exception:
+                LOGGER.exception("graph contradiction scan failed")
+
+        items = conflicts + temporal_items + edge_items + graph_pair_items
         return {
             "items": items,
             "count": len(items),
@@ -373,6 +454,7 @@ class BrainIntelligenceService:
                 "memory_pairs": len(conflicts),
                 "temporal": len(temporal_items),
                 "graph_edges": len(edge_items),
+                "graph_node_pairs": len(graph_pair_items),
             },
             "memories_scanned": len(memory_rows),
             "generated_at": _now(),
@@ -422,6 +504,19 @@ class BrainIntelligenceService:
             except Exception:
                 LOGGER.exception("consolidation prune failed")
 
+        # v9.6.x additive: graph-layer node merge plan. Always dry-run from
+        # this service — graph content changes stay proposal-first; the plan
+        # is surfaced so a governed apply path can adopt it later.
+        graph_consolidation: Optional[Dict[str, Any]] = None
+        proactive = self._proactive()
+        if proactive is not None:
+            try:
+                graph_consolidation = proactive.consolidate_duplicates(
+                    workspace_id=workspace_id, dry_run=True
+                )
+            except Exception:
+                LOGGER.exception("graph consolidation plan failed")
+
         return {
             "mode": "applied" if apply else "dry_run",
             "memories_scanned": len(memory_rows),
@@ -432,6 +527,7 @@ class BrainIntelligenceService:
             # mutates graph content directly.
             "duplicate_edges": duplicate_edge_ids[:50],
             "duplicate_edge_count": len(duplicate_edge_ids),
+            "graph_consolidation": graph_consolidation,
             "generated_at": _now(),
         }
 

package/latticeai/services/change_proposals.py

@@ -0,0 +1,322 @@
+"""Change proposals — 수정/삭제는 제안으로, 생성은 바로 (v9.6.0).
+
+The consent model most users actually want is git's: creating something new
+is cheap and reversible, but changing or deleting what already exists
+deserves a review. This service implements that model for the agent
+workspace:
+
+* **additive** operations (new files, new notes) run with minimal friction;
+* **mutation/destructive** operations (overwrite, in-place edit, delete of
+  an existing file) are *staged as proposals* instead of applied: a review
+  item (source ``change_proposal``) carrying the target path, a unified
+  diff, the exact resulting content, and a small/large tier. Nothing changes
+  on disk until the user approves; rejecting discards the staged change.
+
+Approving applies the staged content exactly as reviewed (never recomputed),
+then marks the review item approved — so the review timeline doubles as the
+change audit log. The classification itself lives in
+:mod:`latticeai.core.tool_governor` so every entry point shares one policy.
+"""
+
+from __future__ import annotations
+
+import difflib
+import logging
+from pathlib import Path
+from typing import Any, Callable, Dict, List, Optional
+
+from latticeai.core.tool_governor import classify_tool_call
+
+LOGGER = logging.getLogger(__name__)
+
+_MAX_STAGED_BYTES = 400_000
+_MAX_DIFF_LINES = 400
+_SMALL_TIER_DIFF_LINES = 40
+
+
+def _unified_diff(before: str, after: str, path: str) -> List[str]:
+    lines = list(
+        difflib.unified_diff(
+            before.splitlines(), after.splitlines(),
+            fromfile=f"a/{path}", tofile=f"b/{path}", lineterm="",
+        )
+    )
+    return lines[:_MAX_DIFF_LINES]
+
+
+class ChangeProposalService:
+    """Stages mutation/destructive file changes as reviewable proposals."""
+
+    #: Tools whose plan-time approval is delegated to per-call governance.
+    governed_tools = frozenset({"write_file", "edit_file"})
+
+    def __init__(
+        self,
+        *,
+        review_queue: Any,
+        resolve_path: Callable[[str], Path],
+        audit: Optional[Callable[..., None]] = None,
+    ) -> None:
+        self._review_queue = review_queue
+        self._resolve_path = resolve_path
+        self._audit = audit or (lambda *a, **kw: None)
+
+    # ── classification / staging (agent-loop governor port) ─────────────
+
+    def review(
+        self,
+        name: str,
+        args: Dict[str, Any],
+        *,
+        policy: Optional[Dict[str, Any]] = None,
+        user_email: Optional[str] = None,
+        workspace_id: Optional[str] = None,
+        conversation_id: Optional[str] = None,
+    ) -> Optional[Dict[str, Any]]:
+        """Governor port for the agent loop.
+
+        Returns ``None`` to fall through to the existing gates, or a verdict:
+        ``{"decision": "allow_additive"}`` (execute without extra approval) /
+        ``{"decision": "proposed", "proposal": {...}}`` (staged for review).
+        """
+        if name not in {"write_file", "edit_file"}:
+            return None
+        verdict = classify_tool_call(
+            name, args, policy=policy, path_exists=self._path_exists
+        )
+        if verdict["change_class"] == "additive":
+            return {"decision": "allow_additive", "classification": verdict}
+        if not verdict["proposal_required"]:
+            return None
+
+        path = str(args.get("path") or "")
+        after = self._staged_content(name, args)
+        if after is None:
+            # The edit cannot be computed deterministically (e.g. old_string
+            # not found) — let the normal tool path surface the real error.
+            return None
+        try:
+            proposal = self.propose_file_update(
+                path=path,
+                new_content=after,
+                proposed_by="agent",
+                reason=verdict["reason"],
+                user_email=user_email,
+                workspace_id=workspace_id,
+                context={
+                    # Full provenance for the Review Center: which tool asked,
+                    # how the governor classified it, and the policy risk.
+                    "tool": name,
+                    "change_class": verdict.get("change_class"),
+                    "risk": (policy or {}).get("risk"),
+                    "conversation_id": conversation_id,
+                    "source_detail": "agent change governor",
+                },
+            )
+        except Exception:
+            LOGGER.exception("change proposal staging failed")
+            return None
+        return {"decision": "proposed", "classification": verdict, "proposal": proposal}
+
+    def _path_exists(self, path: str) -> bool:
+        try:
+            return self._resolve_path(path).is_file()
+        except Exception:
+            return False
+
+    def _read_before(self, path: str) -> str:
+        try:
+            target = self._resolve_path(path)
+            if not target.is_file():
+                return ""
+            raw = target.read_bytes()[:_MAX_STAGED_BYTES]
+            return raw.decode("utf-8", errors="replace")
+        except Exception:
+            LOGGER.exception("change proposal read failed")
+            return ""
+
+    def _staged_content(self, name: str, args: Dict[str, Any]) -> Optional[str]:
+        if name == "write_file":
+            return str(args.get("content") or "")[:_MAX_STAGED_BYTES]
+        if name == "edit_file":
+            before = self._read_before(str(args.get("path") or ""))
+            old = str(args.get("old_string") or "")
+            new = str(args.get("new_string") or "")
+            if not old or old not in before:
+                return None
+            if args.get("replace_all"):
+                return before.replace(old, new)[:_MAX_STAGED_BYTES]
+            if before.count(old) != 1:
+                return None
+            return before.replace(old, new, 1)[:_MAX_STAGED_BYTES]
+        return None
+
+    # ── proposal creation ────────────────────────────────────────────────
+
+    def propose_file_update(
+        self,
+        *,
+        path: str,
+        new_content: str,
+        proposed_by: str = "agent",
+        reason: str = "",
+        user_email: Optional[str] = None,
+        workspace_id: Optional[str] = None,
+        context: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        before = self._read_before(path)
+        diff = _unified_diff(before, new_content, path)
+        tier = "small" if len(diff) <= _SMALL_TIER_DIFF_LINES else "large"
+        provenance: Dict[str, Any] = {"proposed_by": proposed_by, "reason": reason}
+        for key, value in (context or {}).items():
+            if value is not None and key not in provenance:
+                provenance[key] = value
+        item = self._review_queue.create(
+            title=f"파일 수정 제안: {path}",
+            summary=reason or "기존 파일을 변경하는 작업이라 검토 후 적용됩니다.",
+            source="change_proposal",
+            kind="file_update",
+            payload={
+                "path": path,
+                "diff": diff,
+                "new_content": new_content[:_MAX_STAGED_BYTES],
+                "tier": tier,
+                "before_bytes": len(before.encode("utf-8")),
+                "after_bytes": len(new_content.encode("utf-8")),
+            },
+            provenance=provenance,
+            user_email=user_email,
+            workspace_id=workspace_id,
+        )
+        self._audit(
+            "change_proposal_created", user_email=user_email,
+            proposal_id=item.get("id"), path=path, kind="file_update", tier=tier,
+        )
+        return item
+
+    def propose_file_delete(
+        self,
+        *,
+        path: str,
+        proposed_by: str = "agent",
+        reason: str = "",
+        user_email: Optional[str] = None,
+        workspace_id: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        before = self._read_before(path)
+        item = self._review_queue.create(
+            title=f"파일 삭제 제안: {path}",
+            summary=reason or "기존 파일을 삭제하는 작업이라 검토 후 적용됩니다.",
+            source="change_proposal",
+            kind="file_delete",
+            payload={
+                "path": path,
+                "diff": _unified_diff(before, "", path),
+                "tier": "large",
+                "before_bytes": len(before.encode("utf-8")),
+                "after_bytes": 0,
+            },
+            provenance={"proposed_by": proposed_by, "reason": reason},
+            user_email=user_email,
+            workspace_id=workspace_id,
+        )
+        self._audit(
+            "change_proposal_created", user_email=user_email,
+            proposal_id=item.get("id"), path=path, kind="file_delete", tier="large",
+        )
+        return item
+
+    # ── listing / apply / reject ─────────────────────────────────────────
+
+    def pending(
+        self, *, user_email: Optional[str] = None, workspace_id: Optional[str] = None
+    ) -> Dict[str, Any]:
+        listed = self._review_queue.list(
+            workspace_id=workspace_id, user_email=user_email,
+            status="pending", source="change_proposal",
+        )
+        items = listed.get("items") or []
+        return {
+            "items": items,
+            "count": len(items),
+            "contract": {
+                "additive_writes": "auto",
+                "mutations": "proposal",
+                "deletions": "proposal",
+                "applied_content": "exactly_as_reviewed",
+            },
+        }
+
+    def counts(
+        self, *, user_email: Optional[str] = None, workspace_id: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """Pending proposal count for the Review Center badge."""
+        listed = self._review_queue.list(
+            workspace_id=workspace_id, user_email=user_email,
+            status="pending", source="change_proposal",
+        )
+        return {"pending": len(listed.get("items") or [])}
+
+    def get_proposal(
+        self, item_id: str, *, workspace_id: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """Full proposal detail (diff + staged content) for the preview UI.
+
+        Raises ``KeyError`` when the id exists but is not a change proposal,
+        so the API surface cannot leak arbitrary review items.
+        """
+        item = self._review_queue.get(item_id, workspace_id=workspace_id)
+        if item.get("source") != "change_proposal":
+            raise KeyError(f"not a change proposal: {item_id}")
+        return item
+
+    def approve_and_apply(
+        self, item_id: str, *, user_email: Optional[str] = None,
+        workspace_id: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        item = self._review_queue.get(item_id, workspace_id=workspace_id)
+        if item.get("source") != "change_proposal":
+            raise KeyError(f"not a change proposal: {item_id}")
+        payload = item.get("payload") or {}
+        kind = item.get("kind")
+        path = str(payload.get("path") or "")
+        target = self._resolve_path(path)
+        if kind == "file_update":
+            target.parent.mkdir(parents=True, exist_ok=True)
+            target.write_text(str(payload.get("new_content") or ""), encoding="utf-8")
+        elif kind == "file_delete":
+            if target.is_file():
+                target.unlink()
+        else:
+            raise ValueError(f"unknown change proposal kind: {kind}")
+        approved = self._review_queue.approve(item_id, workspace_id=workspace_id)
+        self._audit(
+            "change_proposal_applied", user_email=user_email,
+            proposal_id=item_id, path=path, kind=kind,
+        )
+        return {"item": approved, "applied": True, "path": path, "kind": kind}
+
+    def reject(
+        self, item_id: str, *, user_email: Optional[str] = None,
+        workspace_id: Optional[str] = None, reason: str = "",
+    ) -> Dict[str, Any]:
+        self.get_proposal(item_id, workspace_id=workspace_id)  # source guard
+        reason = str(reason or "").strip()[:500]
+        if reason:
+            try:
+                dismissed = self._review_queue.dismiss(
+                    item_id, workspace_id=workspace_id, reason=reason
+                )
+            except TypeError:
+                # Older/fake queues without reason support still dismiss.
+                dismissed = self._review_queue.dismiss(item_id, workspace_id=workspace_id)
+        else:
+            dismissed = self._review_queue.dismiss(item_id, workspace_id=workspace_id)
+        self._audit(
+            "change_proposal_rejected", user_email=user_email, proposal_id=item_id,
+            reason=reason or None,
+        )
+        return {"item": dismissed, "applied": False, "reason": reason}
+
+
+__all__ = ["ChangeProposalService"]

package/latticeai/services/product_readiness.py

@@ -18,7 +18,7 @@ from typing import Any, Dict, List
 
 from latticeai.services.architecture_readiness import architecture_readiness
 
-PRODUCT_VERSION_TARGET = "9.5.0"
+PRODUCT_VERSION_TARGET = "9.7.0"
 
 
 @dataclass(frozen=True)

package/latticeai/services/review_queue.py

@@ -28,7 +28,10 @@ OPEN_STATUSES = {"pending", "snoozed"}
 TERMINAL_STATUSES = {"approved", "dismissed"}
 ALL_STATUSES = OPEN_STATUSES | TERMINAL_STATUSES
 
-REVIEW_SOURCES = frozenset({"workflow_run", "trigger", "kg_change_digest", "chat_followup", "agent_followup"})
+REVIEW_SOURCES = frozenset({
+    "workflow_run", "trigger", "kg_change_digest", "chat_followup",
+    "agent_followup", "change_proposal",
+})
 
 # Which source statuses each action is allowed from.
 _ALLOWED_FROM: Dict[str, set] = {
@@ -138,8 +141,49 @@ class ReviewQueueService:
         updated = self._store.update_review_item(item_id, workspace_id=workspace_id, **patch)
         return self._view(updated)
 
-    def dismiss(self, item_id: str, *, workspace_id: Optional[str] = None) -> Dict[str, Any]:
-        return self._transition(item_id, "dismiss", "dismissed", workspace_id=workspace_id)
+    def dismiss(
+        self, item_id: str, *, workspace_id: Optional[str] = None,
+        reason: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Dismiss an item; an optional ``reason`` is kept in provenance.
+
+        The reason matters most for ``change_proposal`` items — the review
+        timeline doubles as the change audit log, so "why was this rejected"
+        should survive next to the staged diff.
+        """
+        if not reason:
+            return self._transition(item_id, "dismiss", "dismissed", workspace_id=workspace_id)
+        item = self._store.get_review_item(item_id, workspace_id=workspace_id)
+        self._guard("dismiss", item)
+        provenance = dict(item.get("provenance") or {})
+        provenance["dismiss_reason"] = str(reason)[:500]
+        patch: Dict[str, Any] = {"status": "dismissed", "provenance": provenance}
+        if item.get("snoozed_until") is not None:
+            patch["snoozed_until"] = None
+        updated = self._store.update_review_item(item_id, workspace_id=workspace_id, **patch)
+        return self._view(updated)
+
+    def counts(
+        self, *, workspace_id: Optional[str] = None, user_email: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Badge-friendly effective-status counts (pending includes expired snoozes)."""
+        items = [
+            self._view(it)
+            for it in self._store.list_review_items(
+                workspace_id=workspace_id, user_email=user_email,
+            )
+        ]
+        pending = [it for it in items if it["effective_status"] == "pending"]
+        snoozed = [it for it in items if it["effective_status"] == "snoozed"]
+        by_source: Dict[str, int] = {}
+        for it in pending:
+            source = str(it.get("source") or "workflow_run")
+            by_source[source] = by_source.get(source, 0) + 1
+        return {
+            "pending": len(pending),
+            "snoozed": len(snoozed),
+            "pending_by_source": by_source,
+        }
 
     def snooze(
         self, item_id: str, *, until: str, workspace_id: Optional[str] = None,

package/latticeai/tools/__init__.py

@@ -124,6 +124,11 @@ def _resolve_path(path: str = "") -> Path:
     return candidate
 
 
+def resolve_workspace_path(path: str = "") -> Path:
+    """Public alias of the sandboxed workspace path resolver (v9.6.0)."""
+    return _resolve_path(path)
+
+
 def _relative(path: Path) -> str:
     return str(path.relative_to(AGENT_ROOT))
 
@@ -259,7 +264,7 @@ def execute_tool(action: str, args: Dict[str, Any]) -> Dict[str, Any]:
 
 
 __all__ = [
-    "AGENT_ROOT", "ToolError", "ensure_agent_root",
+    "AGENT_ROOT", "ToolError", "ensure_agent_root", "resolve_workspace_path",
     "list_dir", "workspace_tree", "read_file", "write_file", "edit_file", "grep",
     "search_files", "inspect_html", "preview_url", "create_web_project",
     "todo_read", "todo_write",

package/llm_router.py

@@ -5,7 +5,16 @@ monkeypatching keep working through the old import path.
 """
 
 import sys
+import warnings
 
-import latticeai.models.router as _impl
+warnings.warn(
+    "Importing 'llm_router' from the repository root is deprecated; "
+    "use 'import latticeai.models.router' instead. "
+    "The root shim will be removed in a future major release.",
+    DeprecationWarning,
+    stacklevel=2,
+)
+
+import latticeai.models.router as _impl  # noqa: E402
 
 sys.modules[__name__] = _impl

package/local_knowledge_api.py

@@ -1,7 +1,16 @@
 """Compatibility shim for :mod:`latticeai.services.local_knowledge`."""
 
 import sys
+import warnings
 
-from latticeai.services import local_knowledge as _impl
+warnings.warn(
+    "Importing 'local_knowledge_api' from the repository root is deprecated; "
+    "use 'from latticeai.services import local_knowledge' instead. "
+    "The root shim will be removed in a future major release.",
+    DeprecationWarning,
+    stacklevel=2,
+)
+
+from latticeai.services import local_knowledge as _impl  # noqa: E402
 
 sys.modules[__name__] = _impl

package/ltcai_cli.py

@@ -1,6 +1,16 @@
 """Compatibility shim for the historical root CLI module."""
 
-from latticeai.cli import entrypoint as _impl
+import warnings
+
+warnings.warn(
+    "Importing 'ltcai_cli' from the repository root is deprecated; "
+    "use 'from latticeai.cli import entrypoint' instead. "
+    "The root shim will be removed in a future major release.",
+    DeprecationWarning,
+    stacklevel=2,
+)
+
+from latticeai.cli import entrypoint as _impl  # noqa: E402
 
 
 if __name__ == "__main__":

package/mcp_registry.py

@@ -5,7 +5,16 @@ and monkeypatching keep working through the old import path.
 """
 
 import sys
+import warnings
 
-import latticeai.core.mcp_registry as _impl
+warnings.warn(
+    "Importing 'mcp_registry' from the repository root is deprecated; "
+    "use 'import latticeai.core.mcp_registry' instead. "
+    "The root shim will be removed in a future major release.",
+    DeprecationWarning,
+    stacklevel=2,
+)
+
+import latticeai.core.mcp_registry as _impl  # noqa: E402
 
 sys.modules[__name__] = _impl

package/p_reinforce.py

@@ -1,7 +1,16 @@
 """Compatibility shim for the historical root P-Reinforce module."""
 
 import sys
+import warnings
 
-from latticeai.services import p_reinforce as _impl
+warnings.warn(
+    "Importing 'p_reinforce' from the repository root is deprecated; "
+    "use 'from latticeai.services import p_reinforce' instead. "
+    "The root shim will be removed in a future major release.",
+    DeprecationWarning,
+    stacklevel=2,
+)
+
+from latticeai.services import p_reinforce as _impl  # noqa: E402
 
 sys.modules[__name__] = _impl