ltcai 4.0.1 → 4.2.0

package/latticeai/api/portability.py

@@ -28,6 +28,28 @@ class RestoreRequest(BaseModel):
     verify: bool = True
 
 
+class EncryptedArchiveRequest(BaseModel):
+    path: Optional[str] = None
+    passphrase: str
+
+
+class EncryptedRestoreRequest(BaseModel):
+    path: str
+    passphrase: str
+
+
+class DockerPostgresRequest(BaseModel):
+    consent: bool = False
+    dry_run: bool = False
+    port: int = 5432
+
+
+class SQLiteToPostgresRequest(BaseModel):
+    dsn: str
+    schema_name: str = "lattice_brain"
+    dry_run: bool = True
+
+
 def create_portability_router(
     *,
     service: Any,
@@ -46,6 +68,12 @@ def create_portability_router(
         _require_service()
         return service.snapshot_metadata()
 
+    @router.get("/api/brain/storage")
+    async def brain_storage_status(request: Request):
+        require_user(request)
+        _require_service()
+        return service.storage_status()
+
     @router.get("/api/knowledge-graph/provenance")
     async def recent_provenance(request: Request, limit: int = 50, source_type: Optional[str] = None):
         """Recent ingestions (provenance trail) for the ingestion-sources UI."""
@@ -90,4 +118,45 @@ def create_portability_router(
         except (ValueError, FileNotFoundError) as exc:
             raise HTTPException(status_code=400, detail=str(exc))
 
+    @router.post("/api/knowledge-graph/archive")
+    async def encrypted_archive(req: EncryptedArchiveRequest, request: Request):
+        require_admin(request)
+        _require_service()
+        try:
+            return service.encrypted_archive(req.path, passphrase=req.passphrase)
+        except (ValueError, FileNotFoundError) as exc:
+            raise HTTPException(status_code=400, detail=str(exc))
+
+    @router.post("/api/knowledge-graph/archive/restore")
+    async def restore_encrypted_archive(req: EncryptedRestoreRequest, request: Request):
+        require_admin(request)
+        _require_service()
+        try:
+            return service.restore_encrypted_archive(req.path, passphrase=req.passphrase)
+        except (ValueError, FileNotFoundError) as exc:
+            raise HTTPException(status_code=400, detail=str(exc))
+
+    @router.post("/api/brain/storage/postgres/docker")
+    async def setup_postgres_docker(req: DockerPostgresRequest, request: Request):
+        require_admin(request)
+        _require_service()
+        return service.postgres_docker_setup(
+            consent=req.consent,
+            dry_run=req.dry_run,
+            port=req.port,
+        )
+
+    @router.post("/api/brain/storage/migrate-postgres")
+    async def migrate_sqlite_to_postgres(req: SQLiteToPostgresRequest, request: Request):
+        require_admin(request)
+        _require_service()
+        try:
+            return service.migrate_sqlite_to_postgres(
+                dsn=req.dsn,
+                schema=req.schema_name,
+                dry_run=req.dry_run,
+            )
+        except (ValueError, FileNotFoundError, RuntimeError) as exc:
+            raise HTTPException(status_code=400, detail=str(exc))
+
     return router

package/latticeai/api/setup.py

@@ -19,15 +19,16 @@ from latticeai.models.router import parse_model_ref
 from setup_wizard import get_recommendations, install_stream, open_url, scan_environment
 
 
+class SetupInstallRequest(BaseModel):
+    items: List[Dict]
+
+
 def create_setup_router(*, model_router, require_user) -> APIRouter:
     api_router = APIRouter()
     router = model_router
 
     # ── Setup Wizard ─────────────────────────────────────────────────────────────
-    
-    class SetupInstallRequest(BaseModel):
-        items: List[Dict]
-    
+
     def setup_auto_state() -> Dict[str, object]:
         """Return the PPT-aligned zero-config setup state used by setup UI/API."""
         profile = auto_setup_probe()

package/latticeai/api/static_routes.py

@@ -84,7 +84,7 @@ def create_static_routes_router(
             raise HTTPException(status_code=404)
         return FileResponse(str(p), media_type="application/manifest+json")
 
-    @api_router.api_route("/favicon.ico", methods=["GET", "HEAD"])
+    @api_router.api_route("/favicon.ico", methods=["GET", "HEAD"], include_in_schema=False)
     async def favicon():
         ico = STATIC_DIR / "favicon.ico"
         png = STATIC_DIR / "icons" / "favicon-32.png"
@@ -112,10 +112,10 @@ def create_static_routes_router(
 
     @api_router.get("/app")
     async def app_shell(request: Request):
-        """v3 single-page workspace shell (token-native design system)."""
-        page = STATIC_DIR / "v3" / "index.html"
+        """React desktop single-page workspace shell."""
+        page = STATIC_DIR / "app" / "index.html"
         if not page.exists():
-            raise HTTPException(status_code=404, detail="v3 shell not found.")
+            raise HTTPException(status_code=404, detail="React shell not found.")
         return ui_file_response(page)
 
 

package/latticeai/app_factory.py

@@ -60,7 +60,7 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
     from pydantic import BaseModel
 
     from latticeai.models.router import LLMRouter, normalize_branding
-    from knowledge_graph import KnowledgeGraphStore, set_llm_router
+    from knowledge_graph import set_llm_router
     from local_knowledge_api import LocalKnowledgeWatcher
     from latticeai.core.security import (
         hash_password,
@@ -161,11 +161,12 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
     from latticeai.api.portability import create_portability_router
     from latticeai.services.memory_service import MemoryService
     from latticeai.services.ingestion import IngestionItem, IngestionPipeline
-    from latticeai.brain.conversations import ConversationStore
-    from latticeai.brain.context import ContextAssembler
-    from latticeai.brain.memory import BrainMemory
-    from latticeai.brain.identity import DeviceIdentity
-    from latticeai.brain.network import BrainNetwork
+    from lattice_brain import BrainCore, ConversationStore
+    from lattice_brain.storage import storage_from_env
+    from lattice_brain.context import ContextAssembler
+    from lattice_brain.memory import BrainMemory
+    from lattice_brain.identity import DeviceIdentity
+    from lattice_brain.network import BrainNetwork
     from latticeai.api.network import create_network_router
     from latticeai.services.kg_portability import KGPortabilityService
     # The aliased names below look unused but are part of the legacy
@@ -342,16 +343,22 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
     )
     if EMBEDDER.fell_back:
         logging.warning("Embedding provider %s unavailable: %s", EMBEDDER.requested, EMBEDDER.detail)
-    KNOWLEDGE_GRAPH = KnowledgeGraphStore(
-        DATA_DIR / "knowledge_graph.sqlite",
-        DATA_DIR / "knowledge_graph_blobs",
+    STORAGE_ENGINE = storage_from_env(os.environ, data_dir=DATA_DIR) if ENABLE_GRAPH else None
+    BRAIN_CORE = BrainCore.from_paths(
+        DATA_DIR,
         embedder=EMBEDDER.provider,
+        storage_engine=STORAGE_ENGINE,
     ) if ENABLE_GRAPH else None
+    KNOWLEDGE_GRAPH = BRAIN_CORE.knowledge if BRAIN_CORE is not None else None
     # ── v4 durable conversation store: unbounded episodic memory in the same
     # SQLite file as the graph (kg_portability backup/restore covers it for
     # free). Legacy chat_history.json is imported once, idempotently, and the
     # file is left untouched on disk as the import source.
-    CONVERSATIONS = ConversationStore(DATA_DIR / "knowledge_graph.sqlite")
+    CONVERSATIONS = (
+        BRAIN_CORE.conversations
+        if BRAIN_CORE is not None
+        else ConversationStore(DATA_DIR / "knowledge_graph.sqlite")
+    )
     CONVERSATIONS.import_legacy_json(HISTORY_FILE)
     # Hooks registry is constructed here (ahead of the watcher) so folder-watch
     # reindexes can fire the pre_index/post_index lifecycle hooks.

package/latticeai/brain/__init__.py

@@ -1,18 +1,18 @@
-"""latticeai.brain — the durable substrate of the Digital Brain.
-
-v4 home for the brain's storage modules. The knowledge-graph store itself
-still lives in the root ``knowledge_graph`` module pending its decomposition
-(T3d); new brain components land here first.
-"""
+"""Compatibility namespace for the standalone :mod:`lattice_brain` package."""
 
+from lattice_brain.core import BrainCore, BrainCoreConfig
 from latticeai.brain.context import AssembledContext, ContextAssembler, ContextSection
 from latticeai.brain.conversations import ConversationStore
 from latticeai.brain.memory import BrainMemory
+from latticeai.brain.store import KnowledgeGraphStore
 
 __all__ = [
     "AssembledContext",
+    "BrainCore",
+    "BrainCoreConfig",
     "BrainMemory",
     "ContextAssembler",
     "ContextSection",
     "ConversationStore",
+    "KnowledgeGraphStore",
 ]

package/latticeai/brain/_kg_common.py

@@ -33,7 +33,7 @@ except Exception:  # pragma: no cover - v2 schema is optional at import time
     EdgeType = None  # type: ignore[assignment]
     _exec_script = None  # type: ignore[assignment]
 
-from latticeai.core.local_embeddings import LocalEmbeddingModel
+from lattice_brain.embeddings import LocalEmbeddingModel
 
 # Default read source for the graph queries: v2 reconstruction views.
 # Override with LATTICEAI_KG_READ_V2=0 to fall back to the legacy tables.

package/latticeai/brain/network.py

@@ -23,7 +23,7 @@ import uuid
 from pathlib import Path
 from typing import Any, Dict, List, Optional
 
-from latticeai.brain.identity import DeviceIdentity, fingerprint_of, verify_signature
+from lattice_brain.identity import DeviceIdentity, fingerprint_of, verify_signature
 
 PEER_AUTH_WINDOW_SECONDS = 300
 _NONCE_CACHE_MAX = 4096

package/latticeai/brain/retrieval.py

@@ -813,6 +813,15 @@ class KnowledgeGraphRetrievalMixin:
             raise
 
     def index_status(self) -> Dict[str, Any]:
+        storage_capabilities = None
+        try:
+            storage_capabilities = self.storage_engine.capabilities().as_dict()
+        except Exception as exc:
+            storage_capabilities = {
+                "engine": "sqlite",
+                "available": False,
+                "reason": str(exc),
+            }
         with self._connect() as conn:
             vector_counts = {
                 row["item_type"]: row["count"]
@@ -864,6 +873,12 @@ class KnowledgeGraphRetrievalMixin:
                 # Honest capability report: trigram FTS5 keyword index, or
                 # LIKE-scan fallback when this SQLite build lacks it.
                 "fts_enabled": bool(getattr(self, "_fts_enabled", False)),
+                "engine": storage_capabilities,
+                "vector_search_backend": (
+                    storage_capabilities.get("vector_backend")
+                    if isinstance(storage_capabilities, dict)
+                    else "bruteforce-cosine"
+                ),
             },
             "source_items": len(source_items),
             "indexed_items": sum(vector_counts.values()),

package/latticeai/brain/store.py

@@ -21,11 +21,31 @@ class KnowledgeGraphStore(
     KnowledgeGraphDocumentsMixin,
     KnowledgeGraphRetrievalMixin,
 ):
-    def __init__(self, db_path: Path, blob_dir: Path, embedder: Any = None):
+    def __init__(
+        self,
+        db_path: Path,
+        blob_dir: Path,
+        embedder: Any = None,
+        storage_engine: Any = None,
+    ):
         self.db_path = Path(db_path)
         self.blob_dir = Path(blob_dir)
         self.db_path.parent.mkdir(parents=True, exist_ok=True)
         self.blob_dir.mkdir(parents=True, exist_ok=True)
+        if storage_engine is None:
+            from lattice_brain.storage import SQLiteEngine
+
+            storage_engine = SQLiteEngine(self.db_path)
+        storage_caps = storage_engine.capabilities()
+        if not storage_caps.available:
+            raise RuntimeError(storage_caps.reason or "Brain storage is unavailable.")
+        if storage_caps.engine != "sqlite":
+            raise RuntimeError(
+                "KnowledgeGraphStore currently requires SQLiteEngine. "
+                "Explicit non-SQLite storage must use the migration/scale tooling; "
+                "no SQLite fallback is attempted."
+            )
+        self.storage_engine = storage_engine
         # The embedder is swappable behind a fixed interface
         # (model_id/dim/embed/encode/decode/similarity). Defaults to the
         # deterministic, offline hash model so the store works with no config;
@@ -49,11 +69,7 @@ class KnowledgeGraphStore(
         return ("nodes", "edges")
 
     def _connect(self) -> sqlite3.Connection:
-        conn = sqlite3.connect(str(self.db_path))
-        conn.row_factory = sqlite3.Row
-        conn.execute("PRAGMA journal_mode=WAL")
-        conn.execute("PRAGMA foreign_keys=ON")
-        return conn
+        return self.storage_engine.connect()
 
     def _init_db(self) -> None:
         with self._connect() as conn:

package/latticeai/core/config.py

@@ -104,6 +104,11 @@ class Config:
     embedding_timeout: int
     embedding_custom_target: str
 
+    # ── brain storage ───────────────────────────────────────────────
+    storage_engine: str
+    postgres_dsn: str
+    postgres_schema: str
+
     # ── SSO / OIDC ──────────────────────────────────────────────────
     sso_discovery_url: str
     sso_client_id: str
@@ -185,6 +190,9 @@ class Config:
             embedding_dim=_int(env, "LATTICEAI_VECTOR_DIM", 0),
             embedding_timeout=_int(env, "LATTICEAI_EMBEDDING_TIMEOUT", 30),
             embedding_custom_target=_value(env, "LATTICEAI_EMBEDDING_CUSTOM_TARGET", ""),
+            storage_engine=_value(env, "LATTICEAI_STORAGE_ENGINE", "sqlite").strip().lower() or "sqlite",
+            postgres_dsn=_value(env, "LATTICEAI_POSTGRES_DSN", ""),
+            postgres_schema=_value(env, "LATTICEAI_POSTGRES_SCHEMA", "lattice_brain"),
             sso_discovery_url=_value(env, "OIDC_DISCOVERY_URL", ""),
             sso_client_id=_value(env, "OIDC_CLIENT_ID", ""),
             sso_client_secret=_value(env, "OIDC_CLIENT_SECRET", ""),

package/latticeai/core/marketplace.py

@@ -11,7 +11,7 @@ from copy import deepcopy
 from typing import Any, Dict, List, Optional
 
 
-MARKETPLACE_VERSION = "4.0.1"
+MARKETPLACE_VERSION = "4.2.0"
 TEMPLATE_KINDS = ("plugin", "workflow", "agent")
 
 

package/latticeai/core/multi_agent.py

@@ -14,7 +14,7 @@ from datetime import datetime
 from typing import Any, Callable, Dict, List, Optional
 
 
-MULTI_AGENT_VERSION = "4.0.1"
+MULTI_AGENT_VERSION = "4.2.0"
 
 AGENT_ROLES = ("researcher", "planner", "executor", "reviewer", "release")
 CORE_PIPELINE = ("planner", "executor", "reviewer")

package/latticeai/core/workspace_os.py

@@ -19,7 +19,7 @@ from pathlib import Path
 from typing import Any, Callable, Dict, Iterable, List, Optional
 
 
-WORKSPACE_OS_VERSION = "4.0.1"
+WORKSPACE_OS_VERSION = "4.2.0"
 
 # Workspace types separate single-user Personal workspaces from shared
 # Organization workspaces. Both keep the same local-first JSON store; the type

package/latticeai/services/kg_portability.py

@@ -22,6 +22,13 @@ from datetime import datetime, timezone
 from pathlib import Path
 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"
@@ -95,7 +102,7 @@ class KGPortabilityService:
         origin = "unsigned-legacy"
         signature = artifact.get("signature")
         if signature:
-            from latticeai.brain.identity import verify_manifest
+            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.")
@@ -189,6 +196,36 @@ class KGPortabilityService:
             "nodes": sum(stats.get("nodes", {}).values()),
         }
 
+    # ── 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"
+        archive = EncryptedBrainArchive(
+            BrainArchivePaths(
+                db_path=Path(self._kg.db_path),
+                blob_dir=Path(self._kg.blob_dir),
+            )
+        )
+        return archive.create(dest, passphrase=passphrase)
+
+    def restore_encrypted_archive(self, archive_path, *, passphrase: str) -> Dict[str, Any]:
+        self._require()
+        archive = EncryptedBrainArchive(
+            BrainArchivePaths(
+                db_path=Path(self._kg.db_path),
+                blob_dir=Path(self._kg.blob_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),
+            ),
+        )
+
     # ── status surface ───────────────────────────────────────────────────────
     def snapshot_metadata(self) -> Dict[str, Any]:
         if not self.available():
@@ -198,8 +235,52 @@ class KGPortabilityService:
             **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(),
+        }
+
+    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)
+
+    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),
+        )
+        return migrator.migrate(dry_run=dry_run)
+
     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():

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ltcai",
-  "version": "4.0.1",
+  "version": "4.2.0",
   "description": "Lattice AI — local-first Digital Brain Platform (knowledge graph, durable memory, hybrid search, agents, signed brain exchange)",
   "homepage": "https://github.com/TaeSooPark-PTS/LatticeAI#readme",
   "repository": {
@@ -18,29 +18,36 @@
     "start": "LTCAI",
     "dev": "python3 ltcai_cli.py --reload",
     "build": "npm run build:assets && npm run build:python",
-    "build:assets": "node scripts/build_v3_assets.mjs",
-    "build:python": "python3 -m build",
-    "check:python": "python3 scripts/check_python.py",
-    "lint": "node --check tests/visual/mock_server.cjs && node --check tests/visual/v3.spec.js && npm run lint:v3",
-    "lint:v3": "node scripts/lint_v3.mjs",
-    "typecheck": "cd vscode-extension && npm run build",
-    "test": "python3 -m pytest tests/ -v",
-    "test:unit": "python3 -m pytest tests/unit/ -v",
-    "test:integration": "python3 -m pytest tests/integration/ -v",
+    "frontend:dev": "vite --host 127.0.0.1",
+    "frontend:openapi": "node scripts/run_python.mjs scripts/export_openapi.py frontend/openapi.json && npx openapi-typescript frontend/openapi.json -o frontend/src/api/openapi.ts",
+    "build:assets": "vite build && node scripts/build_frontend_assets.mjs",
+    "build:python": "node scripts/run_python.mjs -m build",
+    "check:python": "node scripts/run_python.mjs scripts/check_python.py",
+    "lint": "node --check tests/visual/mock_server.cjs && node --check tests/visual/v3.spec.js && npm run lint:frontend",
+    "lint:frontend": "node scripts/lint_frontend.mjs",
+    "typecheck": "npm run typecheck:frontend && cd vscode-extension && npm run build",
+    "typecheck:frontend": "npx tsc -p tsconfig.json --noEmit",
+    "test": "node scripts/run_python.mjs -m pytest tests/ -v",
+    "test:unit": "node scripts/run_python.mjs -m pytest tests/unit/ -v",
+    "test:integration": "node scripts/run_python.mjs -m pytest tests/integration/ -v",
     "test:visual": "playwright test",
     "capture:workspace": "node scripts/capture/capture_workspace.js",
     "capture:graph": "node scripts/capture/capture_graph.js",
     "capture:skills": "node scripts/capture/capture_skills.js",
     "capture:enterprise": "node scripts/capture/capture_enterprise.js",
     "capture:onboarding": "node scripts/capture/capture_onboarding.js",
+    "desktop:tauri": "tauri dev",
+    "desktop:tauri:build": "tauri build",
+    "desktop:tauri:check": "cd src-tauri && cargo check",
+    "desktop:electron": "electron desktop/electron/main.cjs",
     "package:vsix": "node scripts/build_vsix.mjs",
     "release:artifacts": "npm run build:assets && npm run build:python && npm pack && npm run package:vsix",
-    "release:validate": "python3 scripts/validate_release_artifacts.py $npm_package_version --require-vsix --require-tgz",
+    "release:validate": "node scripts/run_python.mjs scripts/validate_release_artifacts.py $npm_package_version --require-vsix --require-tgz",
     "publish:npm": "npm pack && npm publish ltcai-$npm_package_version.tgz --access public",
-    "publish:pypi": "npm run build:python && python3 -m twine upload --skip-existing dist/ltcai-$npm_package_version.tar.gz dist/ltcai-$npm_package_version-py3-none-any.whl",
+    "publish:pypi": "npm run build:python && node scripts/run_python.mjs -m twine upload --skip-existing dist/ltcai-$npm_package_version.tar.gz dist/ltcai-$npm_package_version-py3-none-any.whl",
     "publish:vscode": "cd vscode-extension && npm run package:vsix && npm run publish:vscode",
     "publish:openvsx": "cd vscode-extension && npm run package:vsix && npm run publish:openvsx",
-    "publish:all": "npm run release:artifacts && npm run release:validate && npm publish ltcai-$npm_package_version.tgz --access public && python3 -m twine upload --skip-existing dist/ltcai-$npm_package_version.tar.gz dist/ltcai-$npm_package_version-py3-none-any.whl && cd vscode-extension && npm run publish:vscode && npm run publish:openvsx"
+    "publish:all": "npm run release:artifacts && npm run release:validate && npm publish ltcai-$npm_package_version.tgz --access public && node scripts/run_python.mjs -m twine upload --skip-existing dist/ltcai-$npm_package_version.tar.gz dist/ltcai-$npm_package_version-py3-none-any.whl && cd vscode-extension && npm run publish:vscode && npm run publish:openvsx"
   },
   "keywords": [
     "ltcai",
@@ -73,12 +80,14 @@
     "tools/",
     "mcp_registry.py",
     "latticeai/**/*.py",
+    "lattice_brain/**/*.py",
     "skills/",
     "static/favicon.ico",
     "static/manifest.json",
     "static/sw.js",
     "static/css/",
-    "static/v3/",
+    "frontend/",
+    "static/app/",
     "static/icons/",
     "plugins/",
     "scripts/",
@@ -89,6 +98,12 @@
     "setup_wizard.py",
     "knowledge_graph_api.py",
     "static/vendor/",
+    "src-tauri/",
+    "!src-tauri/gen/",
+    "!src-tauri/gen/**",
+    "!src-tauri/target/",
+    "!src-tauri/target/**",
+    "desktop/electron/",
     "docs/*.md",
     "!docs/assets/",
     "!docs/images/"
@@ -97,6 +112,31 @@
     "access": "public"
   },
   "devDependencies": {
-    "@playwright/test": "^1.60.0"
+    "@playwright/test": "^1.60.0",
+    "@tailwindcss/postcss": "^4.3.0",
+    "@tanstack/react-query": "^5.101.0",
+    "@tauri-apps/api": "^2.0.0",
+    "@tauri-apps/cli": "^2.0.0",
+    "@types/cytoscape": "^3.21.9",
+    "@types/react": "^19.2.17",
+    "@types/react-dom": "^19.2.3",
+    "@vitejs/plugin-react": "^6.0.2",
+    "autoprefixer": "^10.5.0",
+    "class-variance-authority": "^0.7.1",
+    "clsx": "^2.1.1",
+    "cytoscape": "^3.34.0",
+    "electron": "^42.4.0",
+    "lucide-react": "^1.17.0",
+    "openapi-fetch": "^0.17.0",
+    "openapi-typescript": "^7.13.0",
+    "postcss": "^8.5.15",
+    "react": "^19.2.7",
+    "react-dom": "^19.2.7",
+    "reactflow": "^11.11.4",
+    "tailwind-merge": "^3.6.0",
+    "tailwindcss": "^4.3.0",
+    "typescript": "^5.9.3",
+    "vite": "^8.0.16",
+    "zustand": "^5.0.14"
   }
 }

package/scripts/build_frontend_assets.mjs

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+const repo = join(import.meta.dirname, "..");
+const appDir = join(repo, "static", "app");
+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 viteManifest = existsSync(nestedViteManifest) ? nestedViteManifest : publicManifest;
+if (!existsSync(viteManifest)) {
+  console.error("Vite manifest missing. Run `vite build` before build_frontend_assets.mjs.");
+  process.exit(1);
+}
+
+const raw = JSON.parse(readFileSync(viteManifest, "utf8"));
+const assets = {};
+for (const [key, value] of Object.entries(raw)) {
+  if (value && typeof value === "object") {
+    if (value.file) assets[key] = `/static/app/${value.file}`;
+    for (const css of value.css || []) assets[css] = `/static/app/${css}`;
+    for (const asset of value.assets || []) assets[asset] = `/static/app/${asset}`;
+  }
+}
+
+const manifest = {
+  version: pkg.version,
+  generated_at: "vite",
+  entrypoints: {
+    app: assets["frontend/index.html"] || "/static/app/index.html",
+  },
+  assets,
+  vite: raw,
+};
+
+writeFileSync(publicManifest, JSON.stringify(manifest, null, 2) + "\n", "utf8");
+console.log(`wrote static/app/asset-manifest.json with ${Object.keys(assets).length} assets`);

package/scripts/bump_version.py

@@ -23,6 +23,7 @@ REPO = Path(__file__).resolve().parents[1]
 # (path, kind, pattern) — pattern groups: (prefix, version)
 TARGETS = [
     ("latticeai/__init__.py", "regex", r'(__version__ = ")([^"]+)(")'),
+    ("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 = ")([^"]+)(")'),
@@ -31,7 +32,9 @@ TARGETS = [
     ("package-lock.json", "package-lock", None),
     ("vscode-extension/package.json", "json", "version"),
     ("vscode-extension/package-lock.json", "package-lock", None),
-    ("static/v3/asset-manifest.json", "json", "version"),
+    ("src-tauri/Cargo.toml", "regex", r'(^version = ")([^"]+)(")'),
+    ("src-tauri/tauri.conf.json", "json", "version"),
+    ("static/app/asset-manifest.json", "json", "version"),
 ]