ltcai 4.3.3 → 4.5.1

package/latticeai/services/kg_portability.py

@@ -1,431 +1,11 @@
-"""Knowledge Graph portability — local export / import / backup / restore.
+"""Compatibility shim: physically moved to ``lattice_brain.portability``.
 
-The Knowledge Graph is the user's durable asset, so it must be portable without
-any cloud service. Two complementary mechanisms, both fully local:
-
-* **Logical export/import** (JSON): nodes/edges/chunks/sources/provenance with a
-  versioned header (schema + projection + embed-dim). Re-embeds on import, so it
-  is portable across machines.
-* **Binary backup/restore** (ZIP): a faithful snapshot of the SQLite DB (incl.
-  vector embeddings) plus the blob directory, integrity-checked, for
-  same-machine recovery.
+Aliases itself to the physical module so identity, module-level state, and
+monkeypatching keep working through the old import path.
 """
 
-from __future__ import annotations
-
-import hashlib
-import json
-import shutil
-import tempfile
-import zipfile
-from datetime import datetime, timezone
-from pathlib import Path, PurePosixPath
-from typing import Any, Dict, Optional
-
-from lattice_brain.archive import BrainArchivePaths, EncryptedBrainArchive
-from lattice_brain.storage import (
-    DockerPostgresWizard,
-    PostgresEngine,
-    SQLiteToPostgresMigrator,
-)
-
-FORMAT = "latticeai.kg.export"
-FORMAT_VERSION = 1
-BACKUP_FORMAT = "latticeai.kg.backup"
-
-
-def _now_iso() -> str:
-    return datetime.now(timezone.utc).isoformat()
-
-
-def _stamp() -> str:
-    return _now_iso().replace(":", "").replace("-", "").replace(".", "")[:15]
-
-
-def _sha256_file(path: Path) -> str:
-    h = hashlib.sha256()
-    with open(path, "rb") as fh:
-        for block in iter(lambda: fh.read(65536), b""):
-            h.update(block)
-    return h.hexdigest()
-
-
-def _safe_zip_names(names) -> None:
-    for name in names:
-        path = PurePosixPath(name)
-        if path.is_absolute() or ".." in path.parts:
-            raise ValueError(f"Backup archive contains unsafe path: {name}")
-
-
-class KGPortabilityService:
-    def __init__(self, *, knowledge_graph: Any, data_dir, enable_graph: bool = True, device_identity: Any = None) -> None:
-        self._kg = knowledge_graph
-        self._data_dir = Path(data_dir)
-        self._enable = bool(enable_graph)
-        self._exports_dir = self._data_dir / "workspace_exports"
-        # v4 sovereignty: when a DeviceIdentity is wired, exports are signed
-        # and imports record origin provenance. Pre-v4 unsigned bundles stay
-        # importable locally (origin='unsigned-legacy') — signatures are
-        # mandatory only on the Brain Network peer path.
-        self._identity = device_identity
-
-    def available(self) -> bool:
-        return self._enable and self._kg is not None
-
-    def _require(self) -> None:
-        if not self.available():
-            raise RuntimeError("Knowledge Graph is disabled (LATTICEAI_ENABLE_GRAPH).")
-
-    # ── logical export / import ──────────────────────────────────────────────
-    def export(self, *, workspace_id: Optional[str] = None) -> Dict[str, Any]:
-        self._require()
-        data = self._kg.export_graph_data(workspace_id=workspace_id)
-        header = {
-            "format": FORMAT,
-            "format_version": FORMAT_VERSION,
-            **self._kg.schema_versions(),
-            "exported_at": _now_iso(),
-            "workspace_id": workspace_id,
-            "counts": data.get("counts"),
-        }
-        artifact = {"header": header, **data}
-        if self._identity is not None:
-            artifact["signature"] = self._identity.sign_manifest(header)
-        return artifact
-
-    def export_to_file(self, path=None, *, workspace_id: Optional[str] = None) -> Dict[str, Any]:
-        artifact = self.export(workspace_id=workspace_id)
-        self._exports_dir.mkdir(parents=True, exist_ok=True)
-        path = Path(path) if path else self._exports_dir / f"kg-export-{_stamp()}.json"
-        path.write_text(json.dumps(artifact, ensure_ascii=False, indent=2), encoding="utf-8")
-        return {"path": str(path), "header": artifact["header"], "bytes": path.stat().st_size}
-
-    def import_data(self, artifact: Dict[str, Any], *, mode: str = "merge", dry_run: bool = False) -> Dict[str, Any]:
-        self._require()
-        if not isinstance(artifact, dict) or "nodes" not in artifact:
-            raise ValueError("Invalid Knowledge Graph export artifact.")
-        if mode not in ("merge", "replace"):
-            raise ValueError("mode must be 'merge' or 'replace'.")
-        origin = "unsigned-legacy"
-        signature = artifact.get("signature")
-        if signature:
-            from lattice_brain.identity import verify_manifest
-
-            if not verify_manifest(artifact.get("header") or {}, signature):
-                raise ValueError("Bundle signature verification failed — refusing to import.")
-            origin = f"device:{signature.get('fingerprint') or 'unknown'}"
-        result = self._kg.import_graph_data(artifact, mode=mode, dry_run=dry_run)
-        result["header"] = artifact.get("header")
-        result["origin"] = origin
-        result["signed"] = bool(signature)
-        if not dry_run:
-            try:
-                self._kg.record_provenance(
-                    node_id="import:" + str((artifact.get("header") or {}).get("exported_at") or _now_iso()),
-                    source_type="bundle_import",
-                    pipeline="kg-portability",
-                    owner=None,
-                    metadata={"origin": origin, "mode": mode,
-                              "counts": (artifact.get("header") or {}).get("counts")},
-                )
-            except Exception:
-                pass
-        return result
-
-    def import_from_file(self, path, *, mode: str = "merge", dry_run: bool = False) -> Dict[str, Any]:
-        artifact = json.loads(Path(path).read_text(encoding="utf-8"))
-        return self.import_data(artifact, mode=mode, dry_run=dry_run)
-
-    # ── binary backup / restore ──────────────────────────────────────────────
-    def backup(self, dest_path=None) -> Dict[str, Any]:
-        self._require()
-        self._exports_dir.mkdir(parents=True, exist_ok=True)
-        dest = Path(dest_path) if dest_path else self._exports_dir / f"kg-backup-{_stamp()}.zip"
-        with tempfile.TemporaryDirectory() as tmp_s:
-            tmp = Path(tmp_s)
-            db_copy = tmp / "knowledge_graph.sqlite"
-            self._kg.backup_database(db_copy)
-            manifest = {
-                "format": BACKUP_FORMAT,
-                "format_version": FORMAT_VERSION,
-                **self._kg.schema_versions(),
-                "created_at": _now_iso(),
-                "db_sha256": _sha256_file(db_copy),
-                "has_blobs": Path(self._kg.blob_dir).exists(),
-            }
-            with zipfile.ZipFile(dest, "w", zipfile.ZIP_DEFLATED) as zf:
-                zf.write(db_copy, "knowledge_graph.sqlite")
-                zf.writestr("manifest.json", json.dumps(manifest, ensure_ascii=False, indent=2))
-                blob_dir = Path(self._kg.blob_dir)
-                if blob_dir.exists():
-                    for f in blob_dir.rglob("*"):
-                        if f.is_file():
-                            zf.write(f, f"blobs/{f.relative_to(blob_dir)}")
-        return {"path": str(dest), "bytes": dest.stat().st_size, "manifest": manifest}
-
-    def restore(
-        self,
-        archive_path,
-        *,
-        verify: bool = True,
-        dry_run: bool = False,
-        confirm: bool = False,
-    ) -> Dict[str, Any]:
-        self._require()
-        archive = Path(archive_path)
-        if not archive.exists():
-            raise FileNotFoundError(f"Backup archive not found: {archive}")
-        if not dry_run and not confirm:
-            raise ValueError("Explicit confirmation is required before restoring a Knowledge Graph backup.")
-        with zipfile.ZipFile(archive) as zf:
-            names = zf.namelist()
-            _safe_zip_names(names)
-            if "knowledge_graph.sqlite" not in names:
-                raise ValueError("Archive is missing knowledge_graph.sqlite.")
-            manifest = json.loads(zf.read("manifest.json")) if "manifest.json" in names else {}
-            with tempfile.TemporaryDirectory() as tmp_s:
-                tmp = Path(tmp_s)
-                zf.extractall(tmp)
-                db_src = tmp / "knowledge_graph.sqlite"
-                if verify and manifest.get("db_sha256"):
-                    if _sha256_file(db_src) != manifest["db_sha256"]:
-                        raise ValueError("Backup integrity check failed (db sha256 mismatch).")
-                if dry_run:
-                    return {
-                        "restored": False,
-                        "dry_run": True,
-                        "verified": True,
-                        "manifest": manifest,
-                        "planned": {
-                            "database": str(self._kg.db_path),
-                            "blobs": str(self._kg.blob_dir),
-                            "archive": str(archive),
-                        },
-                    }
-                db_dest = Path(self._kg.db_path)
-                blob_dest = Path(self._kg.blob_dir)
-                db_dest.parent.mkdir(parents=True, exist_ok=True)
-                # Drop the live DB + stale WAL/SHM siblings so the restored copy
-                # is authoritative (no stale journal overlaying old pages).
-                for sib in (db_dest, Path(str(db_dest) + "-wal"), Path(str(db_dest) + "-shm")):
-                    if sib.exists():
-                        sib.unlink()
-                shutil.copyfile(db_src, db_dest)
-                blob_src = tmp / "blobs"
-                if blob_src.exists():
-                    if blob_dest.exists():
-                        shutil.rmtree(blob_dest)
-                    shutil.copytree(blob_src, blob_dest)
-                else:
-                    blob_dest.mkdir(parents=True, exist_ok=True)
-        stats = self._kg.stats()
-        return {
-            "restored": True,
-            "manifest": manifest,
-            "nodes": sum(stats.get("nodes", {}).values()),
-        }
-
-    def verify_backup(self, archive_path) -> Dict[str, Any]:
-        archive = Path(archive_path)
-        if not archive.exists():
-            return {"ok": False, "path": str(archive), "errors": [f"Backup archive not found: {archive}"]}
-        try:
-            with zipfile.ZipFile(archive) as zf:
-                names = zf.namelist()
-                _safe_zip_names(names)
-                if "knowledge_graph.sqlite" not in names:
-                    raise ValueError("Archive is missing knowledge_graph.sqlite.")
-                manifest = json.loads(zf.read("manifest.json")) if "manifest.json" in names else {}
-                with tempfile.TemporaryDirectory() as tmp_s:
-                    tmp = Path(tmp_s)
-                    zf.extract("knowledge_graph.sqlite", tmp)
-                    db_src = tmp / "knowledge_graph.sqlite"
-                    if manifest.get("db_sha256") and _sha256_file(db_src) != manifest["db_sha256"]:
-                        raise ValueError("Backup integrity check failed (db sha256 mismatch).")
-            return {"ok": True, "path": str(archive), "manifest": manifest, "errors": []}
-        except (ValueError, zipfile.BadZipFile, OSError, json.JSONDecodeError) as exc:
-            return {"ok": False, "path": str(archive), "errors": [str(exc)]}
-
-    # ── encrypted .latticebrain archive ───────────────────────────────────
-    def encrypted_archive(self, dest_path=None, *, passphrase: str) -> Dict[str, Any]:
-        self._require()
-        self._exports_dir.mkdir(parents=True, exist_ok=True)
-        dest = Path(dest_path) if dest_path else self._exports_dir / f"brain-{_stamp()}.latticebrain"
-        metadata = {
-            "storage": self.storage_status().get("active", {}),
-            "snapshot": self.snapshot_metadata(),
-            "device_identity": self._identity.describe() if self._identity is not None else {},
-            "provenance": {"exported_at": _now_iso(), "source": "kg-portability"},
-        }
-        archive = EncryptedBrainArchive(
-            BrainArchivePaths(
-                db_path=Path(self._kg.db_path),
-                blob_dir=Path(self._kg.blob_dir),
-                data_dir=self._data_dir,
-                metadata=metadata,
-            )
-        )
-        return archive.create(dest, passphrase=passphrase)
-
-    def inspect_encrypted_archive(self, archive_path, *, passphrase: Optional[str] = None) -> Dict[str, Any]:
-        archive = EncryptedBrainArchive(
-            BrainArchivePaths(
-                db_path=Path(self._kg.db_path),
-                blob_dir=Path(self._kg.blob_dir),
-                data_dir=self._data_dir,
-            )
-        )
-        return archive.inspect(Path(archive_path), passphrase=passphrase)
-
-    def verify_encrypted_archive(self, archive_path, *, passphrase: str) -> Dict[str, Any]:
-        archive = EncryptedBrainArchive(
-            BrainArchivePaths(
-                db_path=Path(self._kg.db_path),
-                blob_dir=Path(self._kg.blob_dir),
-                data_dir=self._data_dir,
-            )
-        )
-        return archive.verify(Path(archive_path), passphrase=passphrase)
-
-    def restore_encrypted_archive(
-        self,
-        archive_path,
-        *,
-        passphrase: str,
-        dry_run: bool = False,
-        confirm: bool = False,
-    ) -> Dict[str, Any]:
-        self._require()
-        archive = EncryptedBrainArchive(
-            BrainArchivePaths(
-                db_path=Path(self._kg.db_path),
-                blob_dir=Path(self._kg.blob_dir),
-                data_dir=self._data_dir,
-            )
-        )
-        return archive.restore(
-            Path(archive_path),
-            passphrase=passphrase,
-            target=BrainArchivePaths(
-                db_path=Path(self._kg.db_path),
-                blob_dir=Path(self._kg.blob_dir),
-                data_dir=self._data_dir,
-            ),
-            dry_run=dry_run,
-            confirm=confirm,
-        )
-
-    def import_encrypted_archive(
-        self,
-        archive_path,
-        *,
-        passphrase: str,
-        dry_run: bool = False,
-        confirm: bool = False,
-    ) -> Dict[str, Any]:
-        result = self.restore_encrypted_archive(
-            archive_path,
-            passphrase=passphrase,
-            dry_run=dry_run,
-            confirm=confirm,
-        )
-        result["operation"] = "import"
-        return result
-
-    # ── status surface ───────────────────────────────────────────────────────
-    def snapshot_metadata(self) -> Dict[str, Any]:
-        if not self.available():
-            return {"available": False}
-        return {
-            "available": True,
-            **self._kg.schema_versions(),
-            "stats": self._kg.stats(),
-            "provenance": self._kg.provenance_stats(),
-            "storage": (
-                self._kg.storage_engine.capabilities().as_dict()
-                if getattr(self._kg, "storage_engine", None) is not None
-                else {"engine": "sqlite", "available": True}
-            ),
-        }
-
-    def storage_status(self) -> Dict[str, Any]:
-        if not self.available():
-            return {"available": False}
-        return {
-            "available": True,
-            "active": (
-                self._kg.storage_engine.capabilities().as_dict()
-                if getattr(self._kg, "storage_engine", None) is not None
-                else {"engine": "sqlite", "available": True}
-            ),
-            "postgres": PostgresEngine("", schema="lattice_brain").capabilities().as_dict(),
-            "backup_health": self.backup_health(),
-        }
-
-    def backup_health(self) -> Dict[str, Any]:
-        self._exports_dir.mkdir(parents=True, exist_ok=True)
-        backups = sorted(
-            [
-                p for p in self._exports_dir.glob("*")
-                if p.is_file() and (p.suffix == ".zip" or p.suffix == ".latticebrain")
-            ],
-            key=lambda p: p.stat().st_mtime,
-            reverse=True,
-        )
-        latest = backups[0] if backups else None
-        return {
-            "available": True,
-            "directory": str(self._exports_dir),
-            "count": len(backups),
-            "latest": str(latest) if latest else None,
-            "latest_bytes": latest.stat().st_size if latest else 0,
-            "encrypted_archives": sum(1 for p in backups if p.suffix == ".latticebrain"),
-            "zip_backups": sum(1 for p in backups if p.suffix == ".zip"),
-        }
-
-    def postgres_docker_setup(
-        self,
-        *,
-        consent: bool,
-        dry_run: bool = False,
-        port: int = 5432,
-    ) -> Dict[str, Any]:
-        wizard = DockerPostgresWizard(self._data_dir / "postgres", port=port)
-        return wizard.start(consent=consent, dry_run=dry_run)
+import sys
 
-    def migrate_sqlite_to_postgres(
-        self,
-        *,
-        dsn: str,
-        schema: str = "lattice_brain",
-        dry_run: bool = True,
-    ) -> Dict[str, Any]:
-        self._require()
-        if not dsn:
-            raise ValueError("Postgres DSN is required for SQLite to Postgres migration.")
-        migrator = SQLiteToPostgresMigrator(
-            Path(self._kg.db_path),
-            PostgresEngine(dsn, schema=schema),
-        )
-        if dry_run:
-            return migrator.migrate(dry_run=True)
-        backup = self.backup()
-        verification = self.verify_backup(backup["path"])
-        if not verification.get("ok"):
-            raise RuntimeError(
-                "Pre-migration backup verification failed; Postgres migration was not started: "
-                + "; ".join(verification.get("errors") or [])
-            )
-        result = migrator.migrate(dry_run=False)
-        result["pre_migration_backup"] = {
-            "path": backup["path"],
-            "verified": True,
-            "manifest": backup.get("manifest"),
-        }
-        return result
+import lattice_brain.portability as _impl
 
-    def recent_ingestions(self, *, limit: int = 50, source_type: Optional[str] = None) -> Dict[str, Any]:
-        """Recent provenance records (newest first) for the ingestion-sources UI."""
-        if not self.available():
-            return {"items": [], "count": 0}
-        return self._kg.list_provenance(limit=limit, source_type=source_type)
+sys.modules[__name__] = _impl

package/latticeai/services/model_catalog.py

@@ -17,8 +17,8 @@ from typing import Dict, List, Optional
 
 ENGINE_INSTALLERS = {
     "local_mlx": {
-        "command": [sys.executable, "-m", "pip", "install", "--upgrade", "mlx-vlm", "huggingface_hub[cli]"],
-        "label": "Install MLX-VLM runtime",
+        "command": [sys.executable, "-m", "pip", "install", "--upgrade", "mlx-vlm>=0.6.3", "mlx-lm", "huggingface_hub[cli]"],
+        "label": "Install MLX runtime",
     },
     "openai": {
         "command": [sys.executable, "-m", "pip", "install", "openai"],

package/latticeai/services/model_recommendation.py

@@ -18,6 +18,7 @@ from __future__ import annotations
 import re
 from typing import Any, Dict, List, Optional
 
+from latticeai.core.model_compat import model_runtime_compatibility
 from latticeai.services.model_catalog import ENGINE_MODEL_CATALOG
 
 # ── status vocabulary ─────────────────────────────────────────────────────────
@@ -85,14 +86,19 @@ def _engine_available(engine: str, profile: Dict[str, Any]) -> bool:
 def _classify_one(
     model: Dict[str, Any],
     *,
+    engine: str,
     engine_available: bool,
     ram_gb: float,
 ) -> Dict[str, Any]:
     size_gb = parse_size_gb(model.get("size"))
     need_gb = estimated_ram_gb(size_gb) if size_gb is not None else None
+    runtime = model_runtime_compatibility(str(model.get("id") or ""), engine=engine)
 
     if not engine_available:
         status, reason = NOT_RECOMMENDED, "Apple Silicon과 MLX-VLM이 필요합니다"
+    elif runtime.get("supported") is False:
+        status = NOT_RECOMMENDED
+        reason = str(runtime.get("user_message") or "이 모델은 현재 설치된 실행 런타임에서 지원되지 않습니다")
     elif need_gb is None:
         # Tool-managed/pull models have no fixed on-disk size, so treat them as
         # compatible and let the execution tool validate the exact model.
@@ -124,6 +130,7 @@ def _classify_one(
         "run_location": model.get("run_location"),
         "internet_requirement": model.get("internet_requirement"),
         "source_display_order": model.get("source_display_order"),
+        "runtime_compatibility": runtime,
     }
 
 
@@ -148,7 +155,7 @@ def recommend_catalog(profile: Dict[str, Any], *, engine: str = "local_mlx") ->
     ram_gb = _ram_gb(profile)
 
     classified = [
-        _classify_one(m, engine_available=engine_available, ram_gb=ram_gb)
+        _classify_one(m, engine=engine, engine_available=engine_available, ram_gb=ram_gb)
         for m in models
     ]
 

package/latticeai/services/model_runtime.py

@@ -40,6 +40,8 @@ from latticeai.core.model_compat import (
     classify_smoke_response as _classify_smoke_response,
     ensure_profile as _ensure_compat_profile,
     fast_postprocess as _compat_fast_postprocess,
+    friendly_model_runtime_error as _friendly_model_runtime_error,
+    model_runtime_compatibility as _model_runtime_compatibility,
     record_smoke_result as _record_smoke_result,
 )
 from latticeai.core.model_resolution import ModelResolution as _ModelResolution
@@ -931,7 +933,10 @@ def ensure_llamacpp_server(model_name: str) -> None:
 
 def engine_installed(engine: str) -> bool:
     if engine == "local_mlx":
-        return bool(importlib.util.find_spec("mlx") and importlib.util.find_spec("mlx_vlm"))
+        return bool(
+            importlib.util.find_spec("mlx")
+            and (importlib.util.find_spec("mlx_vlm") or importlib.util.find_spec("mlx_lm"))
+        )
     if engine == "ollama":
         return local_binary("ollama") is not None
     if engine == "vllm":
@@ -1042,7 +1047,7 @@ def engine_status() -> List[Dict]:
             "id": "local_mlx",
             "name": "MLX",
             "kind": "local",
-            "description": "Apple Silicon GPU에서 MLX/MLX-VLM 모델을 직접 실행합니다.",
+            "description": "Apple Silicon GPU에서 MLX-VLM 모델을 직접 실행하고, Gemma 4는 필요 시 MLX-LM 텍스트 경로로 재시도합니다.",
             "installed": engine_installed("local_mlx"),
             "installable": True,
             "install_label": ENGINE_INSTALLERS["local_mlx"]["label"],
@@ -1369,6 +1374,9 @@ async def prepare_and_load_model(
     parsed_provider, parsed_model = parse_model_ref(model_id)
     if parsed_provider == "mlx":
         parsed_provider = "local_mlx"
+    compatibility = _model_runtime_compatibility(parsed_model, engine=parsed_provider)
+    if compatibility.get("supported") is False:
+        raise HTTPException(status_code=400, detail=compatibility)
 
     local_engines = {"local_mlx", "ollama", "vllm", "lmstudio", "llamacpp"}
     install_result: Dict[str, object] = {}
@@ -1488,6 +1496,9 @@ async def prepare_and_load_model_stream(
     parsed_provider, parsed_model = parse_model_ref(model_id)
     if parsed_provider == "mlx":
         parsed_provider = "local_mlx"
+    compatibility = _model_runtime_compatibility(parsed_model, engine=parsed_provider)
+    if compatibility.get("supported") is False:
+        raise HTTPException(status_code=400, detail=compatibility)
 
     work_queue: "queue.Queue[Dict[str, object]]" = queue.Queue()
     work_result: Dict[str, object] = {}
@@ -1651,7 +1662,11 @@ async def prepare_and_load_model_stream(
             work_queue.put({"kind": "error", "status_code": exc.status_code, "detail": exc.detail})
         except Exception as exc:
             logging.exception("model prepare stream worker failed")
-            work_queue.put({"kind": "error", "status_code": 500, "detail": str(exc)[-2000:]})
+            work_queue.put({
+                "kind": "error",
+                "status_code": 500,
+                "detail": _friendly_model_runtime_error(exc, model_id=model_id, engine=parsed_provider),
+            })
 
     worker = threading.Thread(target=blocking_prepare, daemon=True)
     worker.start()

package/latticeai/services/platform_runtime.py

@@ -17,9 +17,9 @@ from typing import Any, Callable, Dict, Optional, Set
 
 from fastapi import HTTPException, Request
 
-from latticeai.core.hooks import dispatch_tool
-from latticeai.core.multi_agent import MultiAgentOrchestrator, default_role_runner, llm_role_runner
-from latticeai.core.workflow_engine import ApprovalRequired, WorkflowEngine
+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.workflow import ApprovalRequired, WorkflowEngine
 from tools import execute_tool
 
 

package/latticeai/services/run_executor.py

@@ -13,7 +13,7 @@ from dataclasses import dataclass
 from datetime import datetime
 from typing import Any, Callable, Dict, Optional
 
-from latticeai.core.workflow_engine import WorkflowEngine
+from lattice_brain.workflow import WorkflowEngine
 
 
 ACTIVE_STATUSES = {"queued", "running", "in_progress", "retrying", "cancelling"}

package/latticeai/services/upload_service.py

@@ -9,7 +9,7 @@ from pathlib import Path
 
 from fastapi import HTTPException, Request, UploadFile
 
-from latticeai.services.ingestion import IngestionItem
+from lattice_brain.ingestion import IngestionItem
 from tools import ToolError, read_document
 
 

package/p_reinforce.py

@@ -118,7 +118,7 @@ class PReinforceGardener:
         if self._pipeline is None:
             return {"graph": "unavailable", "graph_detail": "ingestion pipeline not wired"}
         try:
-            from latticeai.services.ingestion import IngestionItem
+            from lattice_brain.ingestion import IngestionItem
 
             ingest = self._pipeline.ingest(
                 IngestionItem(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ltcai",
-  "version": "4.3.3",
+  "version": "4.5.1",
   "description": "Lattice AI — local-first Digital Brain Platform (knowledge graph, durable memory, hybrid search, agents, portable encrypted brain archives)",
   "homepage": "https://github.com/TaeSooPark-PTS/LatticeAI#readme",
   "repository": {

package/scripts/build_frontend_assets.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 
 const repo = join(import.meta.dirname, "..");
@@ -8,6 +8,17 @@ const nestedViteManifest = join(appDir, ".vite", "asset-manifest.json");
 const publicManifest = join(appDir, "asset-manifest.json");
 const pkg = JSON.parse(readFileSync(join(repo, "package.json"), "utf8"));
 
+const assetsDir = join(appDir, "assets");
+if (existsSync(assetsDir)) {
+  for (const name of readdirSync(assetsDir)) {
+    if (!/\.(?:css|js)$/.test(name)) continue;
+    const file = join(assetsDir, name);
+    const text = readFileSync(file, "utf8");
+    const normalized = text.replace(/[ \t]+$/gm, "");
+    if (normalized !== text) writeFileSync(file, normalized, "utf8");
+  }
+}
+
 const viteManifest = existsSync(nestedViteManifest) ? nestedViteManifest : publicManifest;
 if (!existsSync(viteManifest)) {
   console.error("Vite manifest missing. Run `vite build` before build_frontend_assets.mjs.");

package/scripts/bump_version.py

@@ -26,7 +26,7 @@ TARGETS = [
     ("lattice_brain/__init__.py", "regex", r'(__version__ = ")([^"]+)(")'),
     ("latticeai/core/workspace_os.py", "regex", r'(WORKSPACE_OS_VERSION = ")([^"]+)(")'),
     ("latticeai/core/marketplace.py", "regex", r'(MARKETPLACE_VERSION = ")([^"]+)(")'),
-    ("latticeai/core/multi_agent.py", "regex", r'(MULTI_AGENT_VERSION = ")([^"]+)(")'),
+    ("lattice_brain/runtime/multi_agent.py", "regex", r'(MULTI_AGENT_VERSION = ")([^"]+)(")'),
     ("pyproject.toml", "regex", r'(^version = ")([^"]+)(")'),
     ("package.json", "json", "version"),
     ("package-lock.json", "package-lock", None),

package/scripts/wheel_smoke.py

@@ -34,8 +34,15 @@ REPO_ROOT = Path(__file__).resolve().parents[1]
 WHEEL_MODULES = [
     "setup_wizard",
     "lattice_brain",
+    "lattice_brain.graph",
+    "lattice_brain.graph.store",
+    "lattice_brain.runtime",
+    "lattice_brain.runtime.agent_runtime",
     "lattice_brain.storage",
     "lattice_brain.archive",
+    "lattice_brain.ingestion",
+    "lattice_brain.portability",
+    "lattice_brain.workflow",
     "latticeai",
     "latticeai.server_app",
     "latticeai.app_factory",