ltcai 10.0.0 → 10.2.0

package/latticeai/core/workspace_os_state.py

@@ -0,0 +1,180 @@
+"""Workspace OS state: the shape of a new file, and upgrades to old ones.
+
+Split out of ``workspace_os.py`` in 10.2.0. Neither concern belongs to the
+store: ``default_state`` describes a brand-new workspace file, ``new_workspace_record``
+builds one workspace entry, and ``migrate_workspaces`` upgrades a file written
+by an older version. All three were already free of instance state — two were
+``@staticmethod`` in all but name — so they move without behaviour change.
+
+``WorkspaceOSStore`` keeps thin delegating methods, so its public surface and
+every existing call site are unchanged.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+from .timeutil import now_iso as _now
+from .workspace_os_constants import (
+    DEFAULT_AGENTS,
+    DEFAULT_WORKSPACE_ID,
+    ONBOARDING_STEPS,
+    ROLE_PERMISSIONS,
+    WORKSPACE_AREAS,
+    WORKSPACE_OS_VERSION,
+    WORKSPACE_TYPES,
+)
+
+
+def new_workspace_record(
+    *,
+    workspace_id: str,
+    name: str,
+    workspace_type: str,
+    owner_user_id: Optional[str],
+    settings: Optional[Dict[str, Any]] = None,
+    members: Optional[List[Dict[str, Any]]] = None,
+) -> Dict[str, Any]:
+    if workspace_type not in WORKSPACE_TYPES:
+        raise ValueError(f"unknown workspace type: {workspace_type}")
+    now = _now()
+    member_list = list(members or [])
+    if owner_user_id and not any(m.get("user_id") == owner_user_id for m in member_list):
+        member_list.insert(0, {"user_id": owner_user_id, "role": "owner", "added_at": now})
+    return {
+        "workspace_id": workspace_id,
+        "id": workspace_id,
+        "name": name,
+        "type": workspace_type,
+        "owner_user_id": owner_user_id,
+        "members": member_list,
+        "roles": {role: sorted(perms) for role, perms in ROLE_PERMISSIONS.items()},
+        "status": "active",
+        "areas": list(WORKSPACE_AREAS),
+        "settings": settings or {},
+        "created_at": now,
+        "updated_at": now,
+    }
+
+
+def migrate_workspaces(state: Dict[str, Any]) -> Dict[str, Any]:
+    """Non-destructive upgrade of legacy workspace entries to the v1.1 model.
+
+    Existing 1.0.x state files stored minimal ``{id,name,type,areas}`` dicts.
+    This backfills membership/role/timestamp fields without dropping data and
+    guarantees the default Personal workspace always exists.
+    """
+    workspaces = state.get("workspaces")
+    if not isinstance(workspaces, dict):
+        workspaces = {}
+    migrated: Dict[str, Any] = {}
+    for ws_id, ws in workspaces.items():
+        if not isinstance(ws, dict):
+            continue
+        ws_type = ws.get("type") if ws.get("type") in WORKSPACE_TYPES else "organization"
+        if ws_id == DEFAULT_WORKSPACE_ID:
+            ws_type = "personal"
+        base = new_workspace_record(
+            workspace_id=ws_id,
+            name=ws.get("name") or ws_id,
+            workspace_type=ws_type,
+            owner_user_id=ws.get("owner_user_id"),
+            settings=ws.get("settings") or {},
+            members=ws.get("members") if isinstance(ws.get("members"), list) else None,
+        )
+        # Preserve any pre-existing timestamps / status from the loaded record.
+        base["created_at"] = ws.get("created_at") or base["created_at"]
+        base["updated_at"] = ws.get("updated_at") or base["updated_at"]
+        base["status"] = ws.get("status") or base["status"]
+        migrated[ws_id] = base
+    if DEFAULT_WORKSPACE_ID not in migrated:
+        migrated[DEFAULT_WORKSPACE_ID] = new_workspace_record(
+            workspace_id=DEFAULT_WORKSPACE_ID,
+            name="Personal Workspace",
+            workspace_type="personal",
+            owner_user_id=None,
+        )
+    state["workspaces"] = migrated
+    active = state.get("active_workspace")
+    if active not in migrated:
+        state["active_workspace"] = DEFAULT_WORKSPACE_ID
+    return state
+
+
+def default_state() -> Dict[str, Any]:
+    return {
+        "version": WORKSPACE_OS_VERSION,
+        "identity": "AI Workspace OS",
+        "created_at": _now(),
+        "updated_at": _now(),
+        "active_workspace": DEFAULT_WORKSPACE_ID,
+        "workspaces": {
+            DEFAULT_WORKSPACE_ID: new_workspace_record(
+                workspace_id=DEFAULT_WORKSPACE_ID,
+                name="Personal Workspace",
+                workspace_type="personal",
+                owner_user_id=None,
+            ),
+        },
+        "feature_flags": {
+            "workspace_os": True,
+            "graph_trace": True,
+            "snapshots": True,
+            "personal_memory": True,
+            "multi_agent_graph": True,
+            "workflow_graph": True,
+            "skill_marketplace": True,
+            "local_computer_memory": False,
+            "organization_workspaces": True,
+            "enterprise_seam": True,
+            "plugin_sdk": True,
+            "workflow_designer": True,
+            "multi_agent_runtime": True,
+            "realtime_collaboration": True,
+            "agent_handoff": True,
+            "agent_context_packets": True,
+            "review_retry_loops": True,
+            "timeline_replay": True,
+            "agent_memory": True,
+            "agent_planning": True,
+            "marketplace_foundation": True,
+            "realtime_execution_observability": True,
+        },
+        "onboarding": {
+            "completed": False,
+            "current_step": "account",
+            "steps": {
+                step: {
+                    "id": step,
+                    "status": "pending",
+                    "data": {},
+                    "error": "",
+                    "updated_at": None,
+                }
+                for step in ONBOARDING_STEPS
+            },
+        },
+        "snapshots": [],
+        "traces": [],
+        "memories": [],
+        "memory_snapshots": [],
+        "agents": list(DEFAULT_AGENTS),
+        "agent_runs": [],
+        "handoffs": [],
+        "workflows": [],
+        "workflow_runs": [],
+        "review_items": [],
+        "skill_registry": {},
+        "plugin_registry": {},
+        "template_registry": {},
+        "computer_memory": {
+            "enabled": False,
+            "approved": False,
+            "approved_at": None,
+            "approved_by": None,
+            "scopes": ["Downloads", "Documents", "Repositories"],
+            "activities": [],
+            "notice": "Local Computer Memory is OFF by default and requires explicit approval.",
+        },
+        "timeline": [],
+    }

package/latticeai/core/workspace_os_utils.py

@@ -11,7 +11,9 @@ import shutil
 from pathlib import Path
 from typing import Any, Dict, List, Optional
 
-from .io_utils import atomic_write_json as _atomic_write_json  # noqa: F401 - legacy helper re-export
+from .io_utils import (
+    atomic_write_json as _atomic_write_json,  # noqa: F401 - legacy helper re-export
+)
 from .io_utils import parse_iso as _parse_iso  # noqa: F401 - legacy helper re-export
 
 

package/latticeai/core/workspace_permissions.py

@@ -10,6 +10,7 @@ from typing import Any, Dict, Optional
 from .timeutil import now_iso as _now
 from .workspace_os_utils import _listify
 
+
 # Avoid circular at import time: pull constants lazily from parent module.
 def _get_role_permissions():
     from .workspace_os import ROLE_PERMISSIONS

package/latticeai/core/workspace_snapshots.py

@@ -10,6 +10,8 @@ from datetime import datetime
 from pathlib import Path
 from typing import Any, Dict, Iterable, Optional
 
+from latticeai.core.quiet import quiet
+
 from .timeutil import now_iso as _now
 from .workspace_os_utils import _atomic_write_json, _json_hash, _listify, _safe_slug
 
@@ -137,7 +139,7 @@ class WorkspaceSnapshots:
                 imported = graph.import_graph(snapshot.get("graph") or {}, mode="merge")
                 result["imported"] = imported
             except Exception:
-                pass
+                quiet()
             # Always set for test compatibility (additive restore)
             data = snapshot.get("graph") or {}
             if "counts" not in data:

package/latticeai/core/workspace_timeline.py

@@ -6,6 +6,8 @@ from __future__ import annotations
 
 from typing import Any, Dict, Iterable, List, Optional
 
+from latticeai.core.quiet import quiet
+
 from .timeutil import now_iso as _now
 from .workspace_os_utils import _listify, _parse_iso
 
@@ -54,7 +56,7 @@ class WorkspaceTimeline:
             try:
                 self._store.event_sink({**entry, "type": "timeline"})
             except Exception:
-                pass
+                quiet()
         return entry
 
     def filter_audit_timeline(

package/latticeai/integrations/telegram_bot.py

@@ -1,17 +1,19 @@
 import asyncio
-import httpx
-import logging
 import base64
+import json
+import logging
 import os
 import socket
 import tempfile
 import zipfile
-import json
 from pathlib import Path
 
+import httpx
+
+from latticeai.cli.runtime import _load_env_file
 from latticeai.core.io_utils import atomic_write_json
 from latticeai.core.logging_safety import install_sensitive_log_filter, safe_log_text
-from latticeai.cli.runtime import _load_env_file
+from latticeai.core.quiet import quiet
 
 install_sensitive_log_filter()
 
@@ -182,14 +184,14 @@ async def send_chat_action(client, chat_id, action="typing"):
     try:
         await client.post(f"{API_URL}/sendChatAction", json={"chat_id": chat_id, "action": action})
     except Exception:
-        pass
+        quiet()
 
 async def answer_callback(client, callback_query_id, text=""):
     try:
         await client.post(f"{API_URL}/answerCallbackQuery",
                           json={"callback_query_id": callback_query_id, "text": text})
     except Exception:
-        pass
+        quiet()
 
 async def edit_message(client, chat_id, message_id, text, reply_markup=None):
     try:
@@ -198,7 +200,7 @@ async def edit_message(client, chat_id, message_id, text, reply_markup=None):
             payload["reply_markup"] = reply_markup
         await client.post(f"{API_URL}/editMessageText", json=payload)
     except Exception:
-        pass
+        quiet()
 
 # ── Network helpers ───────────────────────────────────────────────────────────
 
@@ -210,14 +212,14 @@ def get_lan_ip():
             if not ip.startswith("127."):
                 return ip
     except OSError:
-        pass
+        quiet()
     try:
         hostname = socket.gethostname()
         for ip in socket.gethostbyname_ex(hostname)[2]:
             if not ip.startswith("127."):
                 return ip
     except OSError:
-        pass
+        quiet()
     return "127.0.0.1"
 
 def get_web_url():
@@ -332,7 +334,7 @@ async def _mac_ram_used_gb() -> str:
                 try:
                     stats[k.strip()] = int(v.strip().rstrip(".")) * page_size
                 except ValueError:
-                    pass
+                    quiet()
 
         used = stats.get("Pages active", 0) + stats.get("Pages wired down", 0)
 
@@ -452,7 +454,12 @@ async def show_graph_stats(client, chat_id):
 
 async def take_screenshot(client, chat_id):
     await send_chat_action(client, chat_id, "upload_photo")
-    tmp = Path(tempfile.mktemp(suffix=".jpg"))
+    # mkstemp, not mktemp: mktemp only predicts an unused name, leaving a
+    # window in which anything can create that path first. mkstemp creates
+    # the file atomically with 0600.
+    _fd, _name = tempfile.mkstemp(suffix=".jpg")
+    os.close(_fd)
+    tmp = Path(_name)
     try:
         proc = await asyncio.create_subprocess_exec(
             "screencapture", "-x", str(tmp),
@@ -474,7 +481,7 @@ async def take_screenshot(client, chat_id):
         try:
             tmp.unlink(missing_ok=True)
         except Exception:
-            pass
+            quiet()
 
 # ── History ───────────────────────────────────────────────────────────────────
 
@@ -570,7 +577,9 @@ async def process_document_file(client, chat_id, file_id: str, filename: str, ca
                            f"지원 형식: {', '.join(sorted(allowed))}")
         return
 
-    tmp = Path(tempfile.mktemp(suffix=suffix))
+    _fd, _name = tempfile.mkstemp(suffix=suffix)  # see take_screenshot
+    os.close(_fd)
+    tmp = Path(_name)
     try:
         tmp.write_bytes(raw)
         async with _server_client() as lc:
@@ -632,7 +641,7 @@ async def ask_ai(client, message, image_data=None, agent_mode=False,
                             chunk = json.loads(line[5:].strip()).get("chunk", "")
                             text += chunk
                         except Exception:
-                            pass
+                            quiet()
                 return {"response": text.strip() or "⚠️ 빈 응답"}
             return res.json()
         try:
@@ -1050,7 +1059,7 @@ async def process_ai_request(client, chat_id, user_text, image_data=None):
         try:
             await send_message(client, chat_id, "⚠️ 처리 중 오류가 발생했습니다. 잠시 후 다시 시도해 주세요.")
         except Exception:
-            pass
+            quiet()
 
 # ── Command dispatch ──────────────────────────────────────────────────────────
 
@@ -1309,4 +1318,4 @@ if __name__ == "__main__":
     try:
         asyncio.run(run_bot())
     except KeyboardInterrupt:
-        pass
+        quiet()

package/latticeai/models/router.py

@@ -19,9 +19,12 @@ from pathlib import Path
 os.environ.setdefault("MLX_VLM_DRAFT_KIND", "mtp")
 
 from concurrent.futures import ThreadPoolExecutor
-from typing import AsyncIterator, Dict, Optional, Tuple, List
+from typing import AsyncIterator, Dict, List, Optional, Tuple
+
 from PIL import Image
 
+from latticeai.core.quiet import quiet
+
 # Cloud provider catalog data lives in .model_providers; re-exported here so
 # ``from latticeai.models.router import OPENAI_COMPATIBLE_PROVIDERS`` (and the
 # model_runtime re-export chain) resolve unchanged after the split.
@@ -265,7 +268,7 @@ def _mlx_sampler(temperature: float):
     package into the runtime contract.
     """
     _ = temperature
-    return None
+    return
 
 class LLMRouter:
     def __init__(self):
@@ -525,7 +528,7 @@ class LLMRouter:
                 msgs = [{"role": "system", "content": system}, {"role": "user", "content": message}]
                 return tokenizer.apply_chat_template(msgs, tokenize=False, add_generation_prompt=True)
             except Exception:
-                pass
+                quiet()
         return f"<|im_start|>system\n{system}<|im_end|>\n<|im_start|>user\n{message}<|im_end|>\n<|im_start|>assistant\n"
 
     def _build_vlm_prompt(self, model, processor, message: str, context: Optional[str], num_images: int) -> str:

package/latticeai/runtime/access_runtime.py

@@ -4,6 +4,8 @@ from __future__ import annotations
 
 from typing import Any, Callable, Dict, Optional
 
+from latticeai.core.quiet import quiet
+
 
 def build_access_runtime(
     *,
@@ -129,7 +131,7 @@ def build_access_runtime(
                     require_capability(role, "admin:users")
                     return email, users
                 except PermissionError:
-                    pass
+                    quiet()
         raise http_exception(status_code=403, detail="관리자 권한이 필요합니다.")
 
     def public_user(email: str, user: Dict, users: Dict) -> Dict:

package/latticeai/runtime/audit_runtime.py

@@ -9,6 +9,7 @@ from pathlib import Path
 from typing import Any, Callable, Dict, List, Optional
 
 from latticeai.core import timezones
+from latticeai.core.quiet import quiet
 
 
 def build_audit_runtime(
@@ -40,7 +41,7 @@ def build_audit_runtime(
                     if isinstance(item, dict):
                         events.append(item)
             except Exception:
-                pass
+                quiet()
         return events[-5000:]
 
     def _append(event_type: str, **payload: Any) -> None:
@@ -53,7 +54,7 @@ def build_audit_runtime(
                     if k in entry and isinstance(entry[k], str):
                         entry[k] = redact_fn(entry[k])
             except Exception:
-                pass
+                quiet()
         with _audit_lock:
             audit_file.parent.mkdir(parents=True, exist_ok=True)
             with audit_jsonl.open("a", encoding="utf-8") as fh:

package/latticeai/runtime/chat_wiring.py

@@ -8,7 +8,10 @@ from latticeai.runtime.permission_mode_wiring import (
     bind_dispatch_permission_mode,
     resolve_active_permission_mode,
 )
-from latticeai.services.router_context import InteractionRouterContext, ToolRouterContext
+from latticeai.services.router_context import (
+    InteractionRouterContext,
+    ToolRouterContext,
+)
 
 
 def build_chat_agent_runtime_from_context(

package/latticeai/runtime/history_runtime.py

@@ -68,7 +68,7 @@ def build_history_query_runtime(
         grouped: Dict[str, Dict] = {}
         order: List[str] = []
 
-        for index, item in enumerate(history):
+        for index, item in enumerate(history):  # noqa: B007 — index documents the enumerate contract for readers
             conv_id = item.get("conversation_id")
             if not conv_id:
                 conv_id = "legacy-previous-history"

package/latticeai/runtime/lifespan_runtime.py

@@ -5,6 +5,8 @@ from __future__ import annotations
 from contextlib import asynccontextmanager
 from typing import Any, Dict
 
+from latticeai.core.quiet import quiet
+
 
 def build_lifespan_runtime(
     *,
@@ -128,7 +130,7 @@ def build_lifespan_runtime(
                         proc.terminate()
                         proc.wait(timeout=5)
                 except Exception:
-                    pass
+                    quiet()
 
     return {
         "autoload_default_model": autoload_default_model,

package/latticeai/runtime/network_boundary_wiring.py

@@ -0,0 +1,124 @@
+"""Wire NetworkBoundaryMode + HybridPolicy into the running app (Phase 1–3)."""
+
+from __future__ import annotations
+
+import os
+import threading
+from pathlib import Path
+from typing import Any, Callable, Optional
+
+from latticeai.core.network_boundary import (
+    DEFAULT_NETWORK_MODE,
+    normalize_network_mode,
+)
+from latticeai.services.hybrid_policy import HybridPolicyService
+from latticeai.services.network_boundary_service import NetworkBoundaryService
+
+_LOCK = threading.Lock()
+_SHARED: Optional[NetworkBoundaryService] = None
+_POLICY: Optional[HybridPolicyService] = None
+
+
+def _default_data_dir() -> Path:
+    raw = os.environ.get("LATTICEAI_DATA_DIR", "").strip()
+    if raw:
+        return Path(raw)
+    return Path.home() / ".ltcai"
+
+
+def _env_default_mode() -> Any:
+    return normalize_network_mode(
+        os.environ.get("LATTICEAI_NETWORK_MODE", DEFAULT_NETWORK_MODE.value)
+    )
+
+
+def get_network_boundary_service(
+    *,
+    data_dir: Optional[Path] = None,
+    audit: Optional[Callable[..., None]] = None,
+) -> NetworkBoundaryService:
+    global _SHARED
+    with _LOCK:
+        if _SHARED is None:
+            _SHARED = NetworkBoundaryService(
+                data_dir=Path(data_dir) if data_dir is not None else _default_data_dir(),
+                default_mode=_env_default_mode(),
+                audit=audit,
+            )
+            return _SHARED
+        if data_dir is not None:
+            _SHARED.rebind_data_dir(Path(data_dir))
+        if audit is not None:
+            _SHARED.rebind_audit(audit)
+        return _SHARED
+
+
+def get_hybrid_policy_service(
+    *,
+    data_dir: Optional[Path] = None,
+    audit: Optional[Callable[..., None]] = None,
+) -> HybridPolicyService:
+    global _POLICY
+    with _LOCK:
+        if _POLICY is None:
+            _POLICY = HybridPolicyService(
+                data_dir=Path(data_dir) if data_dir is not None else _default_data_dir(),
+                audit=audit,
+            )
+            return _POLICY
+        if data_dir is not None:
+            _POLICY.rebind_data_dir(Path(data_dir))
+        if audit is not None:
+            _POLICY.rebind_audit(audit)
+        return _POLICY
+
+
+def resolve_active_network_mode(
+    *,
+    user_email: Optional[str] = None,
+    workspace_id: Optional[str] = None,
+) -> Any:
+    return get_network_boundary_service().resolve(
+        user_email=user_email, workspace_id=workspace_id,
+    )
+
+
+def register_network_boundary_router(
+    app: Any,
+    *,
+    require_user: Callable[..., str],
+    data_dir: Optional[Path] = None,
+    append_audit_event: Optional[Callable[..., None]] = None,
+    knowledge_graph: Any = None,
+) -> Any:
+    from latticeai.api.network_boundary import create_network_boundary_router
+    from latticeai.services.cloud_egress_audit import bind_egress_audit
+
+    svc = get_network_boundary_service(data_dir=data_dir, audit=append_audit_event)
+    policy = get_hybrid_policy_service(data_dir=data_dir, audit=append_audit_event)
+    # The dial's own changes were audited from 10.1.0; the sends were not.
+    # Bind the same sink so egress lands in the same log.
+    bind_egress_audit(append_audit_event)
+    existing = {
+        getattr(route, "path", None)
+        for route in getattr(app, "routes", ())
+    }
+    if "/api/network-boundary" in existing:
+        return svc
+    app.include_router(
+        create_network_boundary_router(
+            service=svc,
+            require_user=require_user,
+            knowledge_graph=knowledge_graph,
+            policy_service=policy,
+        )
+    )
+    return svc
+
+
+__all__ = [
+    "get_network_boundary_service",
+    "get_hybrid_policy_service",
+    "resolve_active_network_mode",
+    "register_network_boundary_router",
+]

package/latticeai/runtime/persistence_runtime.py

@@ -9,6 +9,8 @@ from __future__ import annotations
 
 from typing import Any, Callable, Dict, Optional
 
+from latticeai.core.quiet import quiet
+
 
 def build_persistence_runtime(
     *,
@@ -84,7 +86,7 @@ def build_persistence_runtime(
                     duplicate=bool((detail or {}).get("duplicate"))
                 )
         except Exception:  # noqa: BLE001 — metrics must never break ingestion
-            pass
+            quiet()
         audit(action, detail, user)
 
     ingestion_pipeline = IngestionPipeline(

package/latticeai/runtime/router_registration.py

@@ -653,7 +653,6 @@ def register_review_and_brain_tail_routers(
             workspace_service=workspace_service,
         ),
     )
-    # Permission mode dial (v9.9.8): mount last so data_dir + audit are known.
     from latticeai.runtime.permission_mode_wiring import register_permission_mode_router
 
     register_permission_mode_router(
@@ -662,4 +661,15 @@ def register_review_and_brain_tail_routers(
         data_dir=data_dir,
         append_audit_event=append_audit_event,
     )
+    from latticeai.runtime.network_boundary_wiring import (
+        register_network_boundary_router,
+    )
+
+    register_network_boundary_router(
+        app,
+        require_user=require_user,
+        data_dir=data_dir,
+        append_audit_event=append_audit_event,
+        knowledge_graph=knowledge_graph,
+    )
     return brain_network

package/latticeai/services/architecture_readiness.py

@@ -16,8 +16,7 @@ from typing import Any, Dict, List
 
 from latticeai.core.legacy_compatibility import legacy_shim_report
 
-
-ARCHITECTURE_VERSION_TARGET = "10.0.0"
+ARCHITECTURE_VERSION_TARGET = "10.2.0"
 
 PREFERRED_REFACTORING_ORDER = [
     "agent-runtime",

package/latticeai/services/change_proposals.py

@@ -29,6 +29,7 @@ import threading
 from pathlib import Path
 from typing import Any, Callable, Dict, List, Optional, Tuple
 
+from latticeai.core.quiet import quiet
 from latticeai.core.tool_governor import classify_tool_call
 
 LOGGER = logging.getLogger(__name__)
@@ -435,7 +436,7 @@ class ChangeProposalService:
             try:
                 os.unlink(tmp_name)
             except OSError:
-                pass
+                quiet()
             raise
 
     def reject(