ltcai 8.9.0 → 9.1.0

package/latticeai/core/agent.py

@@ -30,7 +30,8 @@ from typing import Any, Awaitable, Callable, Dict, FrozenSet, List, Optional
 
 from lattice_brain.runtime.hooks import dispatch_tool
 from lattice_brain.runtime.contracts import runtime_boundary_contract, single_agent_contract
-from tools import ToolError
+from latticeai.core.tool_registry import SCOPED_KNOWLEDGE_TOOLS
+from latticeai.tools import ToolError
 
 
 class AgentState(str, Enum):
@@ -155,7 +156,7 @@ class SingleAgentRuntime:
             entrypoint="latticeai.core.agent.SingleAgentRuntime",
             surface="/agent",
             owns="single-agent PLAN / EXECUTE / VERIFY state machine over injected ports",
-            compatibility_aliases=["latticeai.core.agent.AgentRuntime"],
+            compatibility_aliases=[],
         )
 
     def config(self) -> Dict[str, Any]:
@@ -254,12 +255,20 @@ class SingleAgentRuntime:
                 + "\n".join(f"- {c}" for c in ctx.corrections)
             ) if ctx.corrections else ""
 
+            request_workspace = getattr(req, "workspace_id", None)
+            recent_kwargs = {
+                "conversation_id": req.conversation_id,
+                "user_email": current_user or None,
+            }
+            if request_workspace is not None:
+                recent_kwargs["workspace_id"] = request_workspace
+            recent_conversation = d.recent_chat_context(**recent_kwargs) or "(none)"
             context = (
                 f"{d.executor_prompt}\n\n"
                 f"[LANGUAGE HINT: {lang_hint}]\n"
                 f"Workspace root: {d.agent_root}\n\n"
                 f"PLAN:\n{json.dumps(ctx.plan, ensure_ascii=False)}\n\n"
-                f"Recent conversation:\n{d.recent_chat_context(conversation_id=req.conversation_id) or '(none)'}\n\n"
+                f"Recent conversation:\n{recent_conversation}\n\n"
                 f"User request: {req.message}{corrections_hint}\n\n"
                 f"Execution transcript:\n{json.dumps(ctx.transcript, ensure_ascii=False, indent=2)}"
             )
@@ -281,6 +290,13 @@ class SingleAgentRuntime:
             thoughts = str(action.get("thoughts") or "")[:600]
             args     = action.get("args") or {}
 
+            if name in SCOPED_KNOWLEDGE_TOOLS:
+                # Scope is server-owned, never model-owned. Overwrite any
+                # claimed values before policy evaluation, audit, and dispatch.
+                args = dict(args)
+                args["workspace_id"] = request_workspace or "personal"
+                args["user_email"] = current_user or "local"
+
             if name == "final":
                 ctx.final_message = action.get("message", "작업을 완료했습니다.")
                 ctx.transcript.append({
@@ -530,9 +546,3 @@ class SingleAgentRuntime:
                 ctx.state = AgentState.FAILED
 
         ctx.state_history.append(ctx.state.value)
-
-
-# Backward compatibility: external callers historically imported
-# ``latticeai.core.agent.AgentRuntime`` for the single-agent state machine.
-# The product/runtime facade lives at ``lattice_brain.runtime.agent_runtime``.
-AgentRuntime = SingleAgentRuntime

package/latticeai/core/agent_registry.py

@@ -18,7 +18,6 @@ from __future__ import annotations
 import json
 import os
 import tempfile
-from datetime import datetime
 from pathlib import Path
 from typing import Any, Dict, List, Optional
 
@@ -28,14 +27,11 @@ from lattice_brain.runtime.multi_agent import (
     MULTI_AGENT_VERSION,
     ROLE_AGENT_IDS,
 )
+from .timeutil import now_iso as _now
 
 AGENT_TYPES = ("planner", "researcher", "executor", "reviewer", "release", "custom")
 
 
-def _now() -> str:
-    return datetime.now().isoformat(timespec="seconds")
-
-
 # Capabilities + descriptions for the built-in role agents. Kept here as the
 # registry's metadata projection of the roles defined in multi_agent.py.
 ROLE_META: Dict[str, Dict[str, Any]] = {

package/latticeai/core/config.py

@@ -99,6 +99,7 @@ class Config:
     rate_limit_enabled: bool
     open_registration: bool
     invite_code: str
+    invite_cookie_secret: str
     invite_gate_enabled: bool
     admin_emails: List[str]
     trusted_proxies: List[str]
@@ -160,6 +161,7 @@ class Config:
         host = _value(env, "LATTICEAI_HOST", "127.0.0.1")
         port = _port(env, "LATTICEAI_PORT", 4825)
         network_exposed = not host_is_loopback(host)
+        externally_reachable = is_public or network_exposed
 
         cors_extra = [item.strip() for item in _value(env, "LATTICEAI_CORS_ALLOWED_ORIGINS", "").split(",") if item.strip()]
         admin_emails = [item.strip().lower() for item in _value(env, "LATTICEAI_ADMIN_EMAILS", "").split(",") if item.strip()]
@@ -189,13 +191,31 @@ class Config:
             autoload_models=_bool(env, "LATTICEAI_AUTOLOAD_MODELS", default=is_public),
             model_idle_unload_seconds=_int(env, "LATTICEAI_MODEL_IDLE_UNLOAD_SECONDS", 0),
             allow_local_models=_bool(env, "LATTICEAI_ALLOW_LOCAL_MODELS", default=not is_public),
-            require_auth=_bool(env, "LATTICEAI_REQUIRE_AUTH", default=is_public or network_exposed),
+            # Authentication is optional only for the local-first loopback
+            # profile.  An explicit ``false`` must never turn a public/LAN
+            # binding into an unauthenticated service.
+            require_auth=(
+                True
+                if externally_reachable
+                else _bool(env, "LATTICEAI_REQUIRE_AUTH", default=False)
+            ),
             allow_plaintext_api_keys=_bool(env, "LATTICEAI_ALLOW_PLAINTEXT_API_KEYS", default=False),
             cors_allow_network=_bool(env, "LATTICEAI_CORS_ALLOW_NETWORK", default=False),
             cors_extra_origins=cors_extra,
             rate_limit_enabled=_str(env, "LATTICEAI_RATE_LIMIT", "1") != "0",
-            open_registration=_bool(env, "LATTICEAI_OPEN_REGISTRATION", default=not network_exposed and not is_public),
-            invite_code=_value(env, "LATTICEAI_INVITE_CODE", "gemma-lattice-ai"),
+            # Public/LAN startup is closed-registration even if a stale or
+            # unsafe environment file attempts to opt back in.
+            open_registration=(
+                False
+                if externally_reachable
+                else _bool(env, "LATTICEAI_OPEN_REGISTRATION", default=True)
+            ),
+            # There is deliberately no repository-wide/default invitation
+            # code.  When the gate is enabled, the security runtime persists a
+            # cryptographically random code if the operator did not provide
+            # one explicitly.
+            invite_code=_value(env, "LATTICEAI_INVITE_CODE", ""),
+            invite_cookie_secret=_value(env, "LATTICEAI_INVITE_COOKIE_SECRET", ""),
             invite_gate_enabled=_bool(env, "LATTICEAI_INVITE_GATE_ENABLED", default=False),
             admin_emails=admin_emails,
             trusted_proxies=trusted_proxies,

package/latticeai/core/context_builder.py

@@ -23,6 +23,8 @@ def retrieve_context_for_generation(
     *,
     max_results: int = 10,
     max_hops: int = 2,
+    allowed_workspaces=None,
+    include_legacy_global: bool = False,
 ) -> Dict[str, Any]:
     """Knowledge Graph에서 문서 생성에 필요한 컨텍스트를 검색·조합한다.
 
@@ -38,9 +40,21 @@ def retrieve_context_for_generation(
     if not query or not kg_store:
         return {"query": query, "context_markdown": "", "sources": [], "stats": {}}
 
-    results = kg_store.search_for_document_generation(query, limit=max_results)
+    scope_kwargs = (
+        {
+            "allowed_workspaces": allowed_workspaces,
+            "include_legacy_global": include_legacy_global,
+        }
+        if allowed_workspaces is not None
+        else {}
+    )
+    results = kg_store.search_for_document_generation(query, limit=max_results, **scope_kwargs)
     if not results:
-        fallback_ctx = kg_store.context_for_query(query, limit=max_results)
+        fallback_ctx = kg_store.context_for_query(
+            query,
+            limit=max_results,
+            **scope_kwargs,
+        )
         return {
             "query": query,
             "context_markdown": fallback_ctx,
@@ -49,7 +63,11 @@ def retrieve_context_for_generation(
         }
 
     seed_ids = [r["id"] for r in results]
-    hop_data = kg_store.multi_hop_context(seed_ids, max_hops=max_hops)
+    hop_data = kg_store.multi_hop_context(
+        seed_ids,
+        max_hops=max_hops,
+        **scope_kwargs,
+    )
 
     extra_nodes_by_id = {}
     for node in hop_data.get("nodes", []):

package/latticeai/core/invitations.py

@@ -9,10 +9,7 @@ from datetime import datetime, timedelta
 from pathlib import Path
 from typing import Any, Dict, List, Optional
 
-
-def _now() -> datetime:
-    return datetime.now()
-
+from .timeutil import local_now as _now
 
 def _iso(dt: datetime) -> str:
     return dt.isoformat(timespec="seconds")

package/latticeai/core/io_utils.py

@@ -0,0 +1,45 @@
+"""Shared small IO helpers for JSON, timestamps, and file hashes."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+
+def atomic_write_json(path: Path, payload: Dict[str, Any]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tmp_path = path.with_suffix(path.suffix + ".tmp")
+    fd = os.open(tmp_path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
+    with os.fdopen(fd, "w", encoding="utf-8") as handle:
+        handle.write(json.dumps(payload, ensure_ascii=False, indent=2))
+    os.replace(tmp_path, path)
+    try:
+        path.chmod(0o600)
+    except OSError:
+        # Windows and unusual filesystems may not expose POSIX mode bits; the
+        # atomic write is still the safest supported fallback there.
+        pass
+
+
+def parse_iso(value: Optional[str]) -> Optional[datetime]:
+    if not value:
+        return None
+    try:
+        return datetime.fromisoformat(str(value))
+    except (TypeError, ValueError):
+        return None
+
+
+def sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    with open(path, "rb") as fh:
+        for block in iter(lambda: fh.read(65536), b""):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+__all__ = ["atomic_write_json", "parse_iso", "sha256_file"]

package/latticeai/core/legacy_compatibility.py

@@ -14,7 +14,7 @@ from pathlib import Path
 from typing import Any, Dict, List
 
 
-LEGACY_COMPATIBILITY_VERSION = "8.9.0"
+LEGACY_COMPATIBILITY_VERSION = "9.1.0"
 
 
 @dataclass(frozen=True)
@@ -89,13 +89,34 @@ LEGACY_SHIMS: List[LegacyShim] = [
         reason="Deployment docs and local launch scripts historically targeted server.py.",
         removal_phase="major-release-after-8.x",
     ),
+    LegacyShim(
+        path="tools/",
+        owner="latticeai.tools",
+        replacement="from latticeai.tools import execute_tool",
+        reason="Existing integrations and tests import the historical root tools package.",
+        removal_phase="major-release-after-9.x",
+    ),
     LegacyShim(
         path="local_knowledge_api.py",
-        owner="latticeai.api.local_files",
-        replacement="from latticeai.api.local_files import create_local_files_router",
+        owner="latticeai.services.local_knowledge",
+        replacement="from latticeai.services.local_knowledge import create_local_knowledge_router",
         reason="Local folder ingestion integrations used the root local knowledge API.",
         removal_phase="requires-api-route-migration",
     ),
+    LegacyShim(
+        path="auto_setup.py",
+        owner="latticeai.setup.auto_setup",
+        replacement="from latticeai.setup.auto_setup import probe, recommend",
+        reason="Historical scripts invoke the zero-config setup module from the repo root.",
+        removal_phase="major-release-after-9.x",
+    ),
+    LegacyShim(
+        path="setup_wizard.py",
+        owner="latticeai.setup.wizard",
+        replacement="from latticeai.setup.wizard import scan_environment",
+        reason="Older integrations imported the setup wizard from the repo root.",
+        removal_phase="major-release-after-9.x",
+    ),
 ]
 
 # Shim layers that have completed their compatibility window and were

package/latticeai/core/local_embeddings.py

@@ -11,15 +11,13 @@ from __future__ import annotations
 
 import hashlib
 import math
+import os
 import re
 import struct
 from dataclasses import dataclass
 from typing import Iterable, List
 
-# Default controlled via latticeai.core.config.Config.embedding_dim (LATTICEAI_VECTOR_DIM).
-# Removed direct os.getenv per 7.6.0 config centralization (review.md item 3).
-# Callers that need override should pass dim= from Config.
-DEFAULT_EMBEDDING_DIM = 384
+DEFAULT_EMBEDDING_DIM = int(os.getenv("LATTICEAI_VECTOR_DIM", "384"))
 EMBEDDING_MODEL_ID = f"lattice-local-hash-v1:{DEFAULT_EMBEDDING_DIM}"
 
 

package/latticeai/core/marketplace.py

@@ -11,8 +11,8 @@ from copy import deepcopy
 from typing import Any, Dict, List, Optional
 
 
-MARKETPLACE_VERSION = "8.9.0"
-TEMPLATE_KINDS = ("plugin", "workflow", "agent")
+MARKETPLACE_VERSION = "9.1.0"
+TEMPLATE_KINDS = ("plugin", "workflow", "agent", "ingestion_bridge")
 
 
 def _agent_template(
@@ -144,6 +144,37 @@ BUILTIN_TEMPLATES: Dict[str, List[Dict[str, Any]]] = {
             category="automation",
         ),
     ],
+    "ingestion_bridge": [
+        {
+            "id": "bridge-obsidian-markdown",
+            "kind": "ingestion_bridge",
+            "name": "Obsidian Markdown Bridge",
+            "version": "1.0.0",
+            "description": "Import a local Markdown vault through the unified ingestion pipeline.",
+            "metadata": {"category": "interop", "installable": True},
+            "definition": {
+                "source_types": ["local_file", "markdown"],
+                "file_patterns": ["*.md"],
+                "pipeline": "unified-ingestion",
+                "provenance": True,
+                "graph_edges": ["indexed_from", "mentions"],
+            },
+        },
+        {
+            "id": "bridge-calendar-notes",
+            "kind": "ingestion_bridge",
+            "name": "Calendar Notes Bridge",
+            "version": "1.0.0",
+            "description": "Normalize calendar meeting notes into Brain events and source-linked notes.",
+            "metadata": {"category": "interop", "installable": True},
+            "definition": {
+                "source_types": ["workspace_event", "note"],
+                "pipeline": "unified-ingestion",
+                "provenance": True,
+                "graph_edges": ["indexed_from", "mentions"],
+            },
+        },
+    ],
 }