ltcai 10.0.0 → 10.3.0

package/latticeai/services/network_boundary_service.py

@@ -0,0 +1,154 @@
+"""Persisted network-boundary preference for hybrid local + cloud turns.
+
+Mirrors PermissionModeService:
+
+* process default (env ``LATTICEAI_NETWORK_MODE`` or local_only)
+* per-user override
+* per-workspace override (wins over user)
+
+Switching to ``cloud_allowed`` requires ``acknowledge_risk=True`` once; the
+ack is audited. Hard node filters remain in ``latticeai.core.network_boundary``.
+"""
+
+from __future__ import annotations
+
+import json
+import threading
+from pathlib import Path
+from typing import Any, Callable, Dict, Optional
+
+from latticeai.core.io_utils import atomic_write_json
+from latticeai.core.network_boundary import (
+    DEFAULT_NETWORK_MODE,
+    NetworkBoundaryMode,
+    network_mode_catalog,
+    network_mode_contract,
+    normalize_network_mode,
+)
+
+
+class NetworkBoundaryService:
+    """Load / save the network boundary dial."""
+
+    def __init__(
+        self,
+        *,
+        data_dir: Path,
+        default_mode: NetworkBoundaryMode | str = DEFAULT_NETWORK_MODE,
+        audit: Optional[Callable[..., None]] = None,
+    ) -> None:
+        self._path = Path(data_dir) / "network_boundary.json"
+        self._default = normalize_network_mode(default_mode)
+        self._audit = audit or (lambda *a, **kw: None)
+        self._lock = threading.Lock()
+
+    def rebind_data_dir(self, data_dir: Path) -> None:
+        with self._lock:
+            self._path = Path(data_dir) / "network_boundary.json"
+
+    def rebind_audit(self, audit: Callable[..., None]) -> None:
+        with self._lock:
+            self._audit = audit
+
+    def _read(self) -> Dict[str, Any]:
+        if not self._path.exists():
+            return {"default": self._default.value, "users": {}, "workspaces": {}}
+        try:
+            data = json.loads(self._path.read_text(encoding="utf-8"))
+        except Exception:
+            return {"default": self._default.value, "users": {}, "workspaces": {}}
+        if not isinstance(data, dict):
+            return {"default": self._default.value, "users": {}, "workspaces": {}}
+        data.setdefault("default", self._default.value)
+        data.setdefault("users", {})
+        data.setdefault("workspaces", {})
+        return data
+
+    def _write(self, data: Dict[str, Any]) -> None:
+        self._path.parent.mkdir(parents=True, exist_ok=True)
+        atomic_write_json(self._path, data)
+
+    def _resolve_from(
+        self,
+        data: Dict[str, Any],
+        *,
+        user_email: Optional[str],
+        workspace_id: Optional[str],
+    ) -> NetworkBoundaryMode:
+        if workspace_id:
+            ws = (data.get("workspaces") or {}).get(str(workspace_id))
+            if ws:
+                return normalize_network_mode(ws)
+        if user_email:
+            user = (data.get("users") or {}).get(str(user_email).lower())
+            if user:
+                return normalize_network_mode(user)
+        return normalize_network_mode(data.get("default") or self._default)
+
+    def resolve(
+        self,
+        *,
+        user_email: Optional[str] = None,
+        workspace_id: Optional[str] = None,
+    ) -> NetworkBoundaryMode:
+        with self._lock:
+            data = self._read()
+        return self._resolve_from(
+            data, user_email=user_email, workspace_id=workspace_id,
+        )
+
+    def get(
+        self,
+        *,
+        user_email: Optional[str] = None,
+        workspace_id: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        mode = self.resolve(user_email=user_email, workspace_id=workspace_id)
+        contract = network_mode_contract(mode)
+        contract["catalog"] = network_mode_catalog()
+        contract["scope"] = {
+            "user_email": user_email,
+            "workspace_id": workspace_id,
+        }
+        return contract
+
+    def set_mode(
+        self,
+        mode: NetworkBoundaryMode | str,
+        *,
+        user_email: Optional[str] = None,
+        workspace_id: Optional[str] = None,
+        acknowledge_risk: bool = False,
+        source: str = "api",
+    ) -> Dict[str, Any]:
+        mode = normalize_network_mode(mode)
+        if mode == NetworkBoundaryMode.CLOUD_ALLOWED and not acknowledge_risk:
+            raise PermissionError(
+                "cloud_allowed mode requires acknowledge_risk=true "
+                "(minimal related Knowledge Graph nodes may leave this machine)"
+            )
+        with self._lock:
+            data = self._read()
+            previous = self._resolve_from(
+                data, user_email=user_email, workspace_id=workspace_id,
+            )
+            if workspace_id:
+                data.setdefault("workspaces", {})[str(workspace_id)] = mode.value
+            elif user_email:
+                data.setdefault("users", {})[str(user_email).lower()] = mode.value
+            else:
+                data["default"] = mode.value
+            self._write(data)
+        self._audit(
+            "network_boundary_changed",
+            user_email=user_email,
+            workspace_id=workspace_id,
+            previous=previous.value,
+            mode=mode.value,
+            source=source,
+            acknowledge_risk=bool(acknowledge_risk),
+        )
+        return self.get(user_email=user_email, workspace_id=workspace_id)
+
+
+__all__ = ["NetworkBoundaryService"]

package/latticeai/services/openai_compatible_adapter.py

@@ -0,0 +1,100 @@
+"""OpenAI-compatible streaming adapter for hybrid cloud turns (Phase 1).
+
+Uses the already-declared ``openai`` dependency. Configuration is entirely
+environment-driven so no secrets land in the repo:
+
+* ``LATTICEAI_CLOUD_API_KEY`` (required to actually call)
+* ``LATTICEAI_CLOUD_BASE_URL`` (optional; default OpenAI)
+* ``LATTICEAI_CLOUD_MODEL`` (optional; default gpt-4o-mini)
+
+When the API key is missing the adapter raises a clear error so the bridge
+can surface an honest message instead of silently failing.
+"""
+
+from __future__ import annotations
+
+import os
+from typing import AsyncIterator, Optional
+
+
+class OpenAICompatibleAdapter:
+    """Minimal Chat Completions streaming adapter."""
+
+    provider_name = "openai_compatible"
+
+    def __init__(
+        self,
+        *,
+        api_key: Optional[str] = None,
+        base_url: Optional[str] = None,
+        default_model: Optional[str] = None,
+    ) -> None:
+        self.api_key = (api_key or os.environ.get("LATTICEAI_CLOUD_API_KEY") or "").strip()
+        self.base_url = (
+            base_url or os.environ.get("LATTICEAI_CLOUD_BASE_URL") or ""
+        ).strip() or None
+        self.default_model = (
+            default_model
+            or os.environ.get("LATTICEAI_CLOUD_MODEL")
+            or "gpt-4o-mini"
+        ).strip()
+
+    def _client(self):
+        if not self.api_key:
+            raise RuntimeError(
+                "Cloud adapter is not configured. Set LATTICEAI_CLOUD_API_KEY "
+                "(and optionally LATTICEAI_CLOUD_BASE_URL / LATTICEAI_CLOUD_MODEL)."
+            )
+        try:
+            from openai import AsyncOpenAI
+        except ImportError as exc:  # pragma: no cover
+            raise RuntimeError(
+                "openai package is required for the cloud streaming adapter"
+            ) from exc
+        kwargs = {"api_key": self.api_key}
+        if self.base_url:
+            kwargs["base_url"] = self.base_url
+        return AsyncOpenAI(**kwargs)
+
+    async def stream(
+        self,
+        *,
+        system: str,
+        user: str,
+        context: str,
+        model: Optional[str] = None,
+    ) -> AsyncIterator[str]:
+        client = self._client()
+        chosen = (model or self.default_model).strip()
+        messages = [
+            {"role": "system", "content": system},
+        ]
+        if context:
+            messages.append(
+                {
+                    "role": "system",
+                    "content": (
+                        "Local Knowledge Graph context (minimal related nodes only):\n"
+                        f"{context}"
+                    ),
+                }
+            )
+        messages.append({"role": "user", "content": user})
+
+        stream = await client.chat.completions.create(
+            model=chosen,
+            messages=messages,
+            stream=True,
+            temperature=0.2,
+        )
+        async for event in stream:
+            try:
+                delta = event.choices[0].delta
+                piece = getattr(delta, "content", None) or ""
+            except Exception:  # noqa: BLE001
+                piece = ""
+            if piece:
+                yield piece
+
+
+__all__ = ["OpenAICompatibleAdapter"]

package/latticeai/services/p_reinforce.py

@@ -17,6 +17,8 @@ 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")
     or os.getenv("LATTICEAI_BRAIN_DIR")
@@ -213,6 +215,7 @@ class PReinforceGardener:
                             "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}
@@ -273,5 +276,6 @@ class PReinforceGardener:
                     if len(results) >= limit:
                         break
             except Exception:
+                quiet()
                 continue
         return "\n\n".join(results)

package/latticeai/services/platform_runtime.py

@@ -18,8 +18,13 @@ from typing import Any, Callable, Dict, Optional, Set
 from fastapi import HTTPException, Request
 
 from lattice_brain.runtime.hooks import dispatch_tool
-from lattice_brain.runtime.multi_agent import MultiAgentOrchestrator, default_role_runner, llm_role_runner
+from lattice_brain.runtime.multi_agent import (
+    MultiAgentOrchestrator,
+    default_role_runner,
+    llm_role_runner,
+)
 from lattice_brain.workflow import ApprovalRequired, WorkflowEngine
+from latticeai.core.quiet import quiet
 from latticeai.core.tool_registry import SCOPED_KNOWLEDGE_TOOLS
 from latticeai.services.tool_dispatch import enforce_tool_policy
 from latticeai.tools import execute_tool
@@ -178,7 +183,7 @@ class PlatformRuntime:
                 except Exception:
                     # Recall is an enrichment seam; the legacy store fallback
                     # keeps agent execution available if it degrades.
-                    pass
+                    quiet()
             try:
                 mems = self.store.search_memories(goal, user_email=user, workspace_id=scope).get("memories", [])
                 ctx = [str(m.get("content") or "")[:180] for m in mems[:6]]
@@ -188,7 +193,7 @@ class PlatformRuntime:
                     synth = [str(m.get("content") or "")[:160] for m in allm if "agent-synthesis" in (m.get("tags") or [])][:3]
                     ctx = synth + ctx
                 except Exception:
-                    pass
+                    quiet()
                 if not ctx:
                     try:
                         recent = self.store.list_memories(user_email=user, workspace_id=scope).get("memories", [])
@@ -196,7 +201,7 @@ class PlatformRuntime:
                         # itself in the knowledge that just entered the Brain.
                         ctx = [str(m.get("content") or "")[:180] for m in recent[:8]]
                     except Exception:
-                        pass
+                        quiet()
                 return ctx[:8]
             except Exception:
                 return []

package/latticeai/services/process_audit.py

@@ -10,7 +10,6 @@ import time
 from pathlib import Path
 from typing import Any, Iterable, Mapping, Optional, Sequence
 
-
 _SECRET_RE = re.compile(
     r"(api[_-]?key|access[_-]?token|auth[_-]?token|bearer|client[_-]?secret|password|secret|token)",
     re.IGNORECASE,

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 = "10.0.0"
+PRODUCT_VERSION_TARGET = "10.3.0"
 
 
 @dataclass(frozen=True)

package/latticeai/services/run_executor.py

@@ -16,6 +16,7 @@ from lattice_brain.runtime.statuses import (
     RUN_ACTIVE_STATUSES as ACTIVE_STATUSES,
 )
 from lattice_brain.workflow import WorkflowEngine
+from latticeai.core.quiet import quiet
 from latticeai.core.timeutil import now_iso as _now
 
 
@@ -144,7 +145,7 @@ class RunExecutor:
             try:
                 self.append_audit_event("agent_run_failed", user_email=user_email, run_id=run_id, error=str(exc))
             except Exception:
-                pass
+                quiet()
         finally:
             self._handles.pop(run_id, None)
 
@@ -299,7 +300,7 @@ class RunExecutor:
                 workspace_id=workspace_id,
             )
         except Exception:
-            pass
+            quiet()
 
     def _execute_workflow_sync(
         self,

package/latticeai/services/search_service.py

@@ -13,7 +13,6 @@ from typing import Any, Dict, List, Mapping, Optional
 from lattice_brain.graph._kg_fsutil import _parse_iso, _recency_score
 from lattice_brain.graph.retrieval_policy import resolve_policy
 
-
 DEFAULT_HYBRID_WEIGHTS = {
     "keyword": 0.35,
     "vector": 0.40,
@@ -70,9 +69,7 @@ class SearchService:
                 if not node_id or node_id not in scopes:
                     continue
                 scope = scopes[node_id]
-                if scope is None and include_legacy_global:
-                    visible.append(item)
-                elif scope is not None and str(scope) in allowed:
+                if scope is None and include_legacy_global or scope is not None and str(scope) in allowed:
                     visible.append(item)
             return visible
 

package/latticeai/services/setup_detection.py

@@ -6,6 +6,7 @@ import json
 import re
 from typing import Any, Callable, Dict, Iterable, List, Optional, Tuple
 
+from latticeai.core.quiet import quiet
 
 WhichFn = Callable[[str], Optional[str]]
 RunFn = Callable[[List[str]], str]
@@ -32,7 +33,7 @@ def parse_windows_video_controllers(raw: str) -> List[Dict[str, Any]]:
         if controllers:
             return controllers
     except Exception:
-        pass
+        quiet()
     current: Dict[str, Any] = {}
     for line in raw.splitlines():
         if line.startswith("Name="):

package/latticeai/services/tool_dispatch.py

@@ -6,9 +6,9 @@ tool-response shaping are owned outside ``server_app``.
 
 from __future__ import annotations
 
+import subprocess
 from dataclasses import dataclass, field
 from pathlib import Path
-import subprocess
 from typing import Any, Callable, Dict, Mapping, Optional
 
 from fastapi import HTTPException
@@ -30,7 +30,12 @@ from latticeai.core.permission_mode import (
 from latticeai.core.policy import role_has_capability
 from latticeai.core.tool_governor import classify_tool_call
 from latticeai.core.tool_registry import ToolPermission, ToolPolicy
-from latticeai.tools import AGENT_ROOT, DEFAULT_TOOL_REGISTRY, ToolError, ensure_agent_root
+from latticeai.tools import (
+    AGENT_ROOT,
+    DEFAULT_TOOL_REGISTRY,
+    ToolError,
+    ensure_agent_root,
+)
 
 
 def _default_load_users() -> Dict[str, Any]:

package/latticeai/services/upload_service.py

@@ -11,6 +11,7 @@ from typing import Optional
 from fastapi import HTTPException, Request, UploadFile
 
 from lattice_brain.ingestion import IngestionItem
+from latticeai.core.quiet import quiet
 from latticeai.tools import ToolError, read_document
 
 
@@ -161,7 +162,7 @@ async def process_uploaded_document(
         try:
             Path(tmp_path).unlink()
         except OSError:
-            pass
+            quiet()
 
     # ── post_upload hook ── the whole upload → parse → index pipeline finished.
     if hooks is not None:

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.quiet import quiet
 from latticeai.services.process_audit import (
     CommandConfirmationError,
     append_process_audit_event,
@@ -58,6 +59,8 @@ from latticeai.services.setup_detection import (
     detect_cuda,
     detect_tools,
     detect_wsl_from_text,
+)
+from latticeai.services.setup_detection import (
     parse_windows_video_controllers as _parse_windows_video_controllers,
 )
 
@@ -177,7 +180,7 @@ def _detect_gpu(prof_os: str, arch: str) -> GPUInfo:
                 gpu.vram_mb = int(float(mem))
                 gpu.sdk.append("cuda")
             except ValueError:
-                pass
+                quiet()
 
     # Apple Silicon / Metal
     if prof_os == "darwin":
@@ -268,7 +271,7 @@ def _detect_cpu_details(prof_os: str) -> Tuple[str, int, int, List[str]]:
             physical = int((_run(["sysctl", "-n", "hw.physicalcpu"]).strip() or physical))
             logical = int((_run(["sysctl", "-n", "hw.logicalcpu"]).strip() or logical))
         except ValueError:
-            pass
+            quiet()
         flags = [item.lower() for item in _run(["sysctl", "-n", "machdep.cpu.features"]).split()]
     elif prof_os == "linux":
         text = _read_text("/proc/cpuinfo")
@@ -287,19 +290,19 @@ def _detect_cpu_details(prof_os: str) -> Tuple[str, int, int, List[str]]:
                 try:
                     physical = int(value.strip())
                 except ValueError:
-                    pass
+                    quiet()
             elif key == "NumberOfLogicalProcessors" and value.strip():
                 try:
                     logical = int(value.strip())
                 except ValueError:
-                    pass
+                    quiet()
         try:
             import ctypes
             kernel32 = ctypes.windll.kernel32
             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:
-            pass
+            quiet()
     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})
 
@@ -368,14 +371,14 @@ def probe() -> SystemProfile:
                     prof.ram_mb = int(line.split("=", 1)[-1].strip()) // (1024 * 1024)
                     break
     except Exception:
-        pass
+        quiet()
 
     # Disk
     try:
         usage = shutil.disk_usage(Path.home())
         prof.disk_free_mb = usage.free // (1024 * 1024)
     except Exception:
-        pass
+        quiet()
 
     prof.gpu = _detect_gpu(prof.os, prof.arch)
     prof.package_manager = _detect_package_manager(prof.os)

package/latticeai/setup/wizard.py

@@ -21,6 +21,7 @@ import time
 from pathlib import Path
 from typing import Any, AsyncIterator, Dict, List, Tuple
 
+from latticeai.core.quiet import quiet
 from latticeai.services.process_audit import (
     CommandConfirmationError,
     append_process_audit_event,
@@ -32,6 +33,8 @@ from latticeai.services.setup_detection import (
     detect_cuda,
     detect_tools,
     detect_wsl_from_text,
+)
+from latticeai.services.setup_detection import (
     parse_windows_video_controllers as _parse_windows_video_controllers,
 )
 
@@ -304,7 +307,7 @@ def _detect_chip() -> Dict[str, Any]:
                         brand = line.split(":", 1)[-1].strip()
                         break
             except Exception:
-                pass
+                quiet()
         name = brand or platform.processor() or "Unknown CPU"
 
     return {"name": name, "arch": arch, "is_apple_silicon": is_apple, "gen": gen}
@@ -321,7 +324,7 @@ def _detect_cpu() -> Dict[str, Any]:
             physical_cores = int(_cmd(["sysctl", "-n", "hw.physicalcpu"], timeout=5) or physical_cores)
             logical_cores = int(_cmd(["sysctl", "-n", "hw.logicalcpu"], timeout=5) or logical_cores)
         except ValueError:
-            pass
+            quiet()
     elif platform.system() == "Linux":
         try:
             text = Path("/proc/cpuinfo").read_text(encoding="utf-8", errors="replace")
@@ -330,7 +333,7 @@ def _detect_cpu() -> Dict[str, Any]:
                     flags = line.split(":", 1)[-1].strip().lower().split()
                     break
         except Exception:
-            pass
+            quiet()
     elif platform.system() == "Windows":
         raw = _cmd(["wmic", "cpu", "get", "Name,NumberOfCores,NumberOfLogicalProcessors", "/format:list"], timeout=5)
         for line in raw.splitlines():
@@ -341,12 +344,12 @@ def _detect_cpu() -> Dict[str, Any]:
                 try:
                     physical_cores = int(value.strip())
                 except ValueError:
-                    pass
+                    quiet()
             elif key == "NumberOfLogicalProcessors" and value.strip():
                 try:
                     logical_cores = int(value.strip())
                 except ValueError:
-                    pass
+                    quiet()
         try:
             import ctypes
             kernel32 = ctypes.windll.kernel32
@@ -359,7 +362,7 @@ def _detect_cpu() -> Dict[str, Any]:
             }
             flags.extend(name for code, name in feature_map.items() if kernel32.IsProcessorFeaturePresent(code))
         except Exception:
-            pass
+            quiet()
     interesting = {"avx", "avx2", "avx512f", "fma", "neon", "sse4_2"}
     if platform.system() == "Windows":
         interesting.update({"sse", "sse2", "sse3", "rdrand"})
@@ -384,7 +387,7 @@ def _detect_ram_gb() -> float:
         try:
             return round(int(raw) / 1_073_741_824, 1)
         except ValueError:
-            pass
+            quiet()
     if platform.system() == "Darwin":
         profiler = _cmd(["system_profiler", "SPHardwareDataType"], timeout=8)
         m = re.search(r"Memory:\s+([\d.]+)\s*(TB|GB|MB)", profiler, re.IGNORECASE)
@@ -406,7 +409,7 @@ def _detect_ram_gb() -> float:
                 if line.startswith("MemTotal:"):
                     return round(int(line.split()[1]) / 1_048_576, 1)
     except Exception:
-        pass
+        quiet()
     return 0.0
 
 def _detect_disk_free_gb() -> float:
@@ -427,6 +430,7 @@ def _detect_gpu() -> Dict[str, Any]:
                 name, mem = [part.strip() for part in line.split(",", 1)]
                 devices.append({"vendor": "nvidia", "name": name, "vram_mb": int(float(mem)), "backend": "cuda"})
             except Exception:
+                quiet()
                 continue
 
     if platform.system() == "Windows":
@@ -492,7 +496,7 @@ def _detect_wsl() -> Dict[str, Any]:
     try:
         raw = Path("/proc/version").read_text(encoding="utf-8", errors="replace")
     except Exception:
-        pass
+        quiet()
     is_wsl, version = detect_wsl_from_text(platform.system().lower(), raw)
     return {"is_wsl": is_wsl, "version": version}
 
@@ -1243,7 +1247,7 @@ def open_url(url: str) -> None:
             command = ["os.startfile", url]
             plan = command_plan(command, name="open_url", purpose="setup_wizard_open_url")
             append_process_audit_event("setup_wizard_open_url", plan=plan, status="started")
-            os.startfile(url)  # type: ignore[attr-defined]
+            os.startfile(url)  # type: ignore[attr-defined]  # noqa: S606 — fixed program, arguments validated by the caller
             append_process_audit_event("setup_wizard_open_url", plan=plan, status="spawned")
         else:
             command = ["xdg-open", url]
@@ -1260,5 +1264,5 @@ def open_url(url: str) -> None:
                 error=str(exc),
             )
         except Exception:
-            pass
+            quiet()
         pass

package/latticeai/tools/__init__.py

@@ -152,13 +152,13 @@ DOCUMENT_MAX_READ_BYTES = 10_000_000  # 10 MB
 
 
 # ── focused tool submodules (re-exported flat for import compatibility) ───────
+from latticeai.tools.commands import *  # noqa: E402,F401,F403
 from latticeai.tools.computer import *  # noqa: E402,F401,F403
-from latticeai.tools.filesystem import *  # noqa: E402,F401,F403
 from latticeai.tools.documents import *  # noqa: E402,F401,F403
-from latticeai.tools.local_files import *  # noqa: E402,F401,F403
+from latticeai.tools.filesystem import *  # noqa: E402,F401,F403
 from latticeai.tools.knowledge import *  # noqa: E402,F401,F403
+from latticeai.tools.local_files import *  # noqa: E402,F401,F403
 from latticeai.tools.network import *  # noqa: E402,F401,F403
-from latticeai.tools.commands import *  # noqa: E402,F401,F403
 
 
 # ── tool registry: the single name → invocation source of truth ───────────────

package/latticeai/tools/commands.py

@@ -11,19 +11,19 @@ from typing import Any, Dict, List, Optional
 
 import latticeai.tools as tools
 from latticeai.tools import (
-    ToolError,
-    ensure_agent_root,
-    _resolve_path,
-    _relative,
     ALLOWED_COMMANDS,
+    ALLOWED_GIT_SUBCOMMANDS,
     BLOCKED_COMMANDS,
     BUILD_SCRIPT_NAMES,
     DEPLOY_SCRIPT_NAMES,
-    ALLOWED_GIT_SUBCOMMANDS,
-    MAX_COMMAND_SECONDS,
     MAX_BUILD_SECONDS,
-    MAX_DEPLOY_SECONDS,
     MAX_COMMAND_OUTPUT,
+    MAX_COMMAND_SECONDS,
+    MAX_DEPLOY_SECONDS,
+    ToolError,
+    _relative,
+    _resolve_path,
+    ensure_agent_root,
 )
 
 # find(1) flags that execute or delete; checked in run_command.