ltcai 10.0.0 → 10.3.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/history_writer.py

@@ -0,0 +1,138 @@
+"""Persisting one chat turn: redact, audit, store, then grow the Brain.
+
+Extracted from the `app_factory._build` closure in 10.3.0. It was 66 lines
+deep inside a 1,343-line composition root, which meant the one function that
+decides what a chat message looks like *after* redaction — and what the audit
+log records about it — could not be exercised without standing up the whole
+application.
+
+The order here is the contract, and it is deliberate:
+
+1. **Redact first.** Everything downstream (the audit preview, the durable
+   store, the knowledge graph) sees the redacted text, never the original.
+2. **Audit before storing.** The audit row carries a masked preview and the
+   sensitivity verdict, so a message that should not have been sent is
+   visible in the log even if the store write later fails.
+3. **Ingest through the pipeline, not the store.** Chat messages enter the
+   Brain the same way files and web pages do, so they get provenance and the
+   hook lifecycle rather than a direct write that bypasses both.
+4. **A failed ingest does not lose the message.** Graph growth is best-effort;
+   the conversation store is not.
+"""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any, Callable, Dict, Optional
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass(frozen=True)
+class HistoryWriterDeps:
+    """Everything one chat turn needs, injected so this is testable in isolation."""
+
+    conversations: Any
+    append_audit_event: Callable[..., None]
+    classify_sensitive_message: Callable[[Dict[str, Any], int], Dict[str, Any]]
+    redact_secret_text: Callable[[str], str]
+    normalize_branding: Callable[[str], str]
+    ingestion_pipeline: Any = None
+    ingestion_item_factory: Any = None
+    enable_graph: bool = False
+    knowledge_graph: Any = None
+
+
+def write_chat_turn(
+    role: str,
+    message: str,
+    *,
+    user_email: Optional[str] = None,
+    user_nickname: Optional[str] = None,
+    source: Optional[str] = None,
+    conversation_id: Optional[str] = None,
+    workspace_id: Optional[str] = None,
+    deps: HistoryWriterDeps,
+) -> None:
+    """Persist one chat turn. Never raises: a failure here must not lose a reply."""
+    redact_secret_text = deps.redact_secret_text
+    normalize_branding = deps.normalize_branding
+    classify_sensitive_message = deps.classify_sensitive_message
+    append_audit_event = deps.append_audit_event
+    conversations = deps.conversations
+    ingestion_pipeline = deps.ingestion_pipeline
+    ingestion_item_factory = deps.ingestion_item_factory
+    enable_graph = deps.enable_graph
+    knowledge_graph = deps.knowledge_graph
+
+    try:
+        # 1. Redact before anything else sees the text.
+        message = redact_secret_text(message)
+        if role == "assistant":
+            message = normalize_branding(message)
+
+        item: Dict[str, Any] = {
+            "role": role,
+            "content": message,
+            "timestamp": datetime.now().isoformat(),
+        }
+        for key, value in (
+            ("user_email", user_email),
+            ("user_nickname", user_nickname),
+            ("source", source),
+            ("conversation_id", conversation_id),
+            ("workspace_id", workspace_id),
+        ):
+            if value:
+                item[key] = value
+
+        # 2. Audit carries a masked preview and the verdict, never the body.
+        sensitive = classify_sensitive_message(item, -1)
+        append_audit_event(
+            "chat_message",
+            role=role,
+            user_email=user_email,
+            user_nickname=user_nickname,
+            source=source,
+            conversation_id=conversation_id,
+            workspace_id=workspace_id,
+            content_preview=sensitive.get("preview"),
+            content_chars=len(message or ""),
+            sensitivity=sensitive.get("sensitivity"),
+            sensitive_labels=sensitive.get("labels") or [],
+        )
+
+        # 3. Durable episodic memory. Unbounded SQLite; the old 50-message
+        #    chat_history.json cap is gone.
+        conversations.append(item)
+
+        # 4. Best-effort Brain growth through the unified pipeline.
+        if enable_graph and knowledge_graph and ingestion_pipeline and ingestion_item_factory:
+            try:
+                ingestion_pipeline.ingest(
+                    ingestion_item_factory(
+                        source_type="chat_message",
+                        text=message,
+                        owner=user_email,
+                        workspace_id=workspace_id,
+                        conversation_id=conversation_id,
+                        metadata={
+                            "role": role,
+                            "user_nickname": user_nickname,
+                            "source": source,
+                            "raw": item,
+                        },
+                    ),
+                    user_email=user_email,
+                )
+            except Exception as graph_error:  # noqa: BLE001
+                # The message is already stored; a graph failure must not
+                # look like a lost turn.
+                logger.warning("knowledge graph message ingest failed: %s", graph_error)
+    except Exception as exc:  # noqa: BLE001
+        logger.warning("save_to_history failed: %s", exc)
+
+
+__all__ = ["HistoryWriterDeps", "write_chat_turn"]

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,