ltcai 8.8.0 → 8.9.0

package/latticeai/api/tools.py

@@ -3,11 +3,12 @@
 from __future__ import annotations
 
 import base64
+import inspect
 import io
 import logging
 import shutil
 from pathlib import Path
-from typing import Dict, List, Optional
+from typing import Any, Dict, List, Optional
 
 from fastapi import APIRouter, File, HTTPException, Request, UploadFile
 from fastapi.responses import FileResponse
@@ -24,6 +25,7 @@ from latticeai.services.tool_dispatch import (
     TOOL_GOVERNANCE_DEFAULT as _TOOL_GOVERNANCE_DEFAULT,
     check_tool_role as _check_tool_role,
     get_tool_permission,
+    enforce_tool_policy,
     list_tool_permissions,
     tool_registry_diagnostics,
     tool_registry_manifest,
@@ -253,7 +255,21 @@ def create_tools_router(
 
     # ── Direct Tool API ───────────────────────────────────────────────────────────
     
-    def _tool_response(fn, *args, **kwargs):
+    def _policy_args(fn, *args, **kwargs) -> Dict:
+        try:
+            bound = inspect.signature(fn).bind_partial(*args, **kwargs)
+            return dict(bound.arguments)
+        except Exception:
+            return dict(kwargs)
+
+    def _tool_response(
+        fn,
+        *args,
+        current_user: Optional[str] = None,
+        source: str = "http",
+        trusted_admin: bool = False,
+        **kwargs,
+    ):
         # Shared tool lifecycle (same path as the agent + workflow tool calls):
         # pre_tool (may block) → execute → post_tool. Keyword args are forwarded
         # to the tool and surfaced in the hook payload so read_file / edit_file /
@@ -261,7 +277,16 @@ def create_tools_router(
         # tool instead of bypassing it.
         tool_name = getattr(fn, "__name__", "tool")
         try:
-            result = dispatch_tool(HOOKS, tool_name, dict(kwargs), lambda: fn(*args, **kwargs), source="http")
+            policy_args = _policy_args(fn, *args, **kwargs)
+            if current_user is not None:
+                enforce_tool_policy(
+                    tool_name,
+                    policy_args,
+                    current_user=current_user,
+                    source=source,
+                    trusted_admin=trusted_admin,
+                )
+            result = dispatch_tool(HOOKS, tool_name, dict(kwargs), lambda: fn(*args, **kwargs), source=source)
         except PermissionError as exc:
             raise HTTPException(status_code=403, detail=str(exc))
         except ToolError as exc:
@@ -277,47 +302,58 @@ def create_tools_router(
             raise HTTPException(status_code=403, detail=str(exc))
         except ToolError as exc:
             raise HTTPException(status_code=400, detail=str(exc))
+
+    def _history_scope(user_email: str) -> Dict[str, Any]:
+        require_auth = bool(getattr(CONFIG, "require_auth", False))
+        scope: Dict[str, Any] = {
+            "user_email": user_email if require_auth else None,
+            "allowed_workspaces": None,
+            "include_legacy_global": not require_auth,
+        }
+        if require_auth and user_email and allowed_workspaces_for is not None:
+            scope["allowed_workspaces"] = allowed_workspaces_for(user_email)
+        return scope
     
     
     @api_router.post("/tools/list_dir")
     async def tools_list_dir(req: ToolPathRequest, request: Request):
-        require_user(request)
-        return _tool_response(list_dir, req.path)
+        current_user = require_user(request)
+        return _tool_response(list_dir, req.path, current_user=current_user)
     
     
     @api_router.post("/tools/workspace_tree")
     async def tools_workspace_tree(req: ToolWorkspaceTreeRequest, request: Request):
-        require_user(request)
-        return _tool_response(workspace_tree, req.path, req.max_depth)
+        current_user = require_user(request)
+        return _tool_response(workspace_tree, req.path, req.max_depth, current_user=current_user)
     
     
     @api_router.post("/tools/read_file")
     async def tools_read_file(req: ToolReadFileRequest, request: Request):
-        require_user(request)
-        return _tool_response(read_file, req.path, offset=req.offset, limit=req.limit, line_numbers=req.line_numbers)
+        current_user = require_user(request)
+        return _tool_response(read_file, req.path, offset=req.offset, limit=req.limit, line_numbers=req.line_numbers, current_user=current_user)
     
     
     @api_router.post("/tools/write_file")
     async def tools_write_file(req: ToolWriteFileRequest, request: Request):
-        require_user(request)
-        return _tool_response(write_file, req.path, req.content)
+        current_user = require_user(request)
+        return _tool_response(write_file, req.path, req.content, current_user=current_user)
     
     
     @api_router.post("/tools/edit_file")
     async def tools_edit_file(req: ToolEditFileRequest, request: Request):
-        require_user(request)
-        return _tool_response(edit_file, req.path, req.old_string, req.new_string, replace_all=req.replace_all)
+        current_user = require_user(request)
+        return _tool_response(edit_file, req.path, req.old_string, req.new_string, replace_all=req.replace_all, current_user=current_user)
     
     
     @api_router.post("/tools/search_files")
     async def tools_search_files(req: ToolSearchFilesRequest, request: Request):
-        require_user(request)
-        return _tool_response(search_files, req.query, req.path, req.max_results)
+        current_user = require_user(request)
+        return _tool_response(search_files, req.query, req.path, req.max_results, current_user=current_user)
     
     
     @api_router.post("/tools/grep")
     async def tools_grep(req: ToolGrepRequest, request: Request):
-        require_user(request)
+        current_user = require_user(request)
         return _tool_response(
             grep,
             req.pattern,
@@ -326,25 +362,31 @@ def create_tools_router(
             max_results=req.max_results,
             case_insensitive=req.case_insensitive,
             context_lines=req.context_lines,
+            current_user=current_user,
         )
     
     
     @api_router.post("/tools/todo_read")
     async def tools_todo_read(request: Request):
-        require_user(request)
-        return _tool_response(todo_read)
+        current_user = require_user(request)
+        return _tool_response(todo_read, current_user=current_user)
     
     
     @api_router.post("/tools/todo_write")
     async def tools_todo_write(req: ToolTodoWriteRequest, request: Request):
-        require_user(request)
-        return _tool_response(todo_write, req.todos)
+        current_user = require_user(request)
+        return _tool_response(todo_write, req.todos, current_user=current_user)
     
     
     @api_router.post("/tools/clear_history")
     async def tools_clear_history(req: ToolClearHistoryRequest, request: Request):
         current_user = require_user(request)
-        result = _dispatch("clear_history", {"keep_last": req.keep_last}, lambda: clear_history(req.keep_last))
+        scope = _history_scope(current_user)
+        result = _dispatch(
+            "clear_history",
+            {"keep_last": req.keep_last, **scope},
+            lambda: clear_history(req.keep_last, **scope),
+        )
         append_audit_event(
             "history_delete",
             user_email=current_user,
@@ -358,38 +400,38 @@ def create_tools_router(
     
     @api_router.post("/tools/inspect_html")
     async def tools_inspect_html(req: ToolPathRequest, request: Request):
-        require_user(request)
-        return _tool_response(inspect_html, req.path)
+        current_user = require_user(request)
+        return _tool_response(inspect_html, req.path, current_user=current_user)
     
     
     @api_router.post("/tools/preview_url")
     async def tools_preview_url(req: ToolPathRequest, request: Request):
-        require_user(request)
-        return _tool_response(preview_url, req.path)
+        current_user = require_user(request)
+        return _tool_response(preview_url, req.path, current_user=current_user)
     
     
     @api_router.post("/tools/create_docx")
     async def tools_create_docx(req: ToolDocxRequest, request: Request):
-        require_user(request)
-        return _tool_response(create_docx, req.title, req.body, req.filename)
+        current_user = require_user(request)
+        return _tool_response(create_docx, req.title, req.body, req.filename, current_user=current_user)
     
     
     @api_router.post("/tools/create_xlsx")
     async def tools_create_xlsx(req: ToolXlsxRequest, request: Request):
-        require_user(request)
-        return _tool_response(create_xlsx, req.rows, req.filename, req.sheet_name)
+        current_user = require_user(request)
+        return _tool_response(create_xlsx, req.rows, req.filename, req.sheet_name, current_user=current_user)
     
     
     @api_router.post("/tools/create_pptx")
     async def tools_create_pptx(req: ToolPptxRequest, request: Request):
-        require_user(request)
-        return _tool_response(create_pptx, req.title, req.slides, req.filename)
+        current_user = require_user(request)
+        return _tool_response(create_pptx, req.title, req.slides, req.filename, current_user=current_user)
     
     
     @api_router.post("/tools/create_pdf")
     async def tools_create_pdf(req: ToolPdfRequest, request: Request):
-        require_user(request)
-        return _tool_response(create_pdf, req.title, req.body, req.filename)
+        current_user = require_user(request)
+        return _tool_response(create_pdf, req.title, req.body, req.filename, current_user=current_user)
     
     
     @api_router.post("/tools/read_document")
@@ -402,7 +444,7 @@ def create_tools_router(
                 action="read",
                 user_email=current_user,
             )
-        return _tool_response(read_document, req.path)
+        return _tool_response(read_document, req.path, current_user=current_user)
     
     
     @api_router.get("/tools/pdf_pages")
@@ -503,38 +545,38 @@ def create_tools_router(
 
     @api_router.post("/tools/knowledge_save")
     async def tools_knowledge_save(req: ToolKnowledgeSaveRequest, request: Request):
-        require_user(request)
-        return _tool_response(knowledge_save, req.content, req.folder, req.title)
+        current_user = require_user(request)
+        return _tool_response(knowledge_save, req.content, req.folder, req.title, current_user=current_user)
     
     
     @api_router.post("/tools/knowledge_search")
     async def tools_knowledge_search(req: ToolKnowledgeSearchRequest, request: Request):
-        require_user(request)
-        return _tool_response(knowledge_search, req.query, req.max_results)
+        current_user = require_user(request)
+        return _tool_response(knowledge_search, req.query, req.max_results, current_user=current_user)
     
     
     @api_router.get("/tools/knowledge_tree")
     async def tools_knowledge_tree(request: Request):
-        require_user(request)
-        return _tool_response(knowledge_tree)
+        current_user = require_user(request)
+        return _tool_response(knowledge_tree, current_user=current_user)
     
     
     @api_router.post("/tools/obsidian_save")
     async def tools_obsidian_save(req: ToolKnowledgeSaveRequest, request: Request):
-        require_user(request)
-        return _tool_response(obsidian_save, req.content, req.folder, req.title)
+        current_user = require_user(request)
+        return _tool_response(obsidian_save, req.content, req.folder, req.title, current_user=current_user)
     
     
     @api_router.post("/tools/obsidian_search")
     async def tools_obsidian_search(req: ToolKnowledgeSearchRequest, request: Request):
-        require_user(request)
-        return _tool_response(obsidian_search, req.query, req.max_results)
+        current_user = require_user(request)
+        return _tool_response(obsidian_search, req.query, req.max_results, current_user=current_user)
     
     
     @api_router.get("/tools/obsidian_tree")
     async def tools_obsidian_tree(request: Request):
-        require_user(request)
-        return _tool_response(obsidian_tree)
+        current_user = require_user(request)
+        return _tool_response(obsidian_tree, current_user=current_user)
     
     
     @api_router.get("/obsidian/status")
@@ -550,50 +592,50 @@ def create_tools_router(
     
     @api_router.get("/tools/git_status")
     async def tools_git_status(request: Request):
-        require_user(request)
-        return _tool_response(git_status)
+        current_user = require_user(request)
+        return _tool_response(git_status, current_user=current_user)
     
     
     @api_router.post("/tools/git_diff")
     async def tools_git_diff(req: ToolGitDiffRequest, request: Request):
-        require_user(request)
-        return _tool_response(git_diff, req.path, req.cwd)
+        current_user = require_user(request)
+        return _tool_response(git_diff, req.path, req.cwd, current_user=current_user)
     
     
     @api_router.post("/tools/git_log")
     async def tools_git_log(req: ToolGitLogRequest, request: Request):
-        require_user(request)
-        return _tool_response(git_log, req.max_count, req.cwd)
+        current_user = require_user(request)
+        return _tool_response(git_log, req.max_count, req.cwd, current_user=current_user)
     
     
     @api_router.post("/tools/git_show")
     async def tools_git_show(req: ToolGitShowRequest, request: Request):
-        require_user(request)
-        return _tool_response(git_show, req.revision, req.cwd)
+        current_user = require_user(request)
+        return _tool_response(git_show, req.revision, req.cwd, current_user=current_user)
     
     
     @api_router.post("/tools/run_command")
     async def tools_run_command(req: ToolRunCommandRequest, request: Request):
-        require_admin(request)
-        return _tool_response(run_command, req.command, req.cwd)
+        current_user, _users = require_admin(request)
+        return _tool_response(run_command, req.command, req.cwd, current_user=current_user, trusted_admin=True)
     
     
     @api_router.get("/tools/network_status")
     async def tools_network_status(request: Request):
-        require_user(request)
-        return _tool_response(network_status)
+        current_user = require_user(request)
+        return _tool_response(network_status, current_user=current_user)
     
     
     @api_router.post("/tools/build_project")
     async def tools_build_project(req: ToolScriptRequest, request: Request):
-        require_admin(request)
-        return _tool_response(build_project, req.cwd, req.script)
+        current_user, _users = require_admin(request)
+        return _tool_response(build_project, req.cwd, req.script, current_user=current_user, trusted_admin=True)
     
     
     @api_router.post("/tools/deploy_project")
     async def tools_deploy_project(req: ToolScriptRequest, request: Request):
-        require_admin(request)
-        return _tool_response(deploy_project, req.cwd, req.script)
+        current_user, _users = require_admin(request)
+        return _tool_response(deploy_project, req.cwd, req.script, current_user=current_user, trusted_admin=True)
     
     
     @api_router.get("/tools/permissions")

package/latticeai/app_factory.py

@@ -15,6 +15,7 @@ lazily via module ``__getattr__`` for backwards compatibility.
 from __future__ import annotations
 
 import threading
+from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, Dict, List, Optional
 
 from latticeai.runtime.app_context_runtime import build_app_context
@@ -94,7 +95,7 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
     from pydantic import BaseModel
 
     from latticeai.models.router import LLMRouter, normalize_branding
-    from lattice_brain.graph._kg_common import set_llm_router
+    from lattice_brain.graph.runtime import set_llm_router
     from lattice_brain.graph.schema import set_embed_dim
     from latticeai.core.security import (
         hash_password,
@@ -234,6 +235,8 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
     ENABLE_GRAPH    = _config_runtime["ENABLE_GRAPH"]
     AUTOLOAD_MODELS = _config_runtime["AUTOLOAD_MODELS"]
     MODEL_IDLE_UNLOAD_SECONDS = _config_runtime["MODEL_IDLE_UNLOAD_SECONDS"]
+    ALLOW_MODEL_DOWNLOADS = _config_runtime["ALLOW_MODEL_DOWNLOADS"]
+    MODEL_DOWNLOAD_TIMEOUT = _config_runtime["MODEL_DOWNLOAD_TIMEOUT"]
     ALLOW_LOCAL_MODELS = _config_runtime["ALLOW_LOCAL_MODELS"]
     REQUIRE_AUTH = _config_runtime["REQUIRE_AUTH"]
     ALLOW_PLAINTEXT_API_KEYS = _config_runtime["ALLOW_PLAINTEXT_API_KEYS"]
@@ -636,9 +639,33 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
     get_audit_log = _audit_rt["get_audit_log"]
     append_audit_event = _audit_rt["append_audit_event"]
 
-    def get_history():
+    def _history_allowed_workspaces_for(user_email: Optional[str]):
+        if not REQUIRE_AUTH or not user_email:
+            return None
+        try:
+            return set(WORKSPACE_SERVICE.readable_workspaces(user_email))
+        except Exception as exc:
+            logging.warning("history workspace scope resolution failed for %s: %s", user_email, exc)
+            return set()
+
+    def _history_include_legacy_global(user_email: Optional[str]) -> bool:
+        return not REQUIRE_AUTH or not user_email
+
+    def get_history(
+        user_email: Optional[str] = None,
+        allowed_workspaces=None,
+        include_legacy_global: Optional[bool] = None,
+    ):
         try:
-            return CONVERSATIONS.history()
+            if allowed_workspaces is None and user_email:
+                allowed_workspaces = _history_allowed_workspaces_for(user_email)
+            if include_legacy_global is None:
+                include_legacy_global = _history_include_legacy_global(user_email)
+            return CONVERSATIONS.history(
+                user_email=user_email,
+                allowed_workspaces=allowed_workspaces,
+                include_legacy_global=include_legacy_global,
+            )
         except Exception as e:
             logging.warning("get_history failed: %s", e)
             return []
@@ -683,17 +710,59 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
 
         return sorted((conversations[key] for key in order), key=lambda item: item.get("updated_at") or "", reverse=True)
 
-    def get_conversation_messages(conversation_id: str) -> List[Dict]:
-        history = get_history()
+    def get_conversation_messages(
+        conversation_id: str,
+        *,
+        user_email: Optional[str] = None,
+        allowed_workspaces=None,
+        include_legacy_global: Optional[bool] = None,
+    ) -> List[Dict]:
+        history = get_history(
+            user_email=user_email,
+            allowed_workspaces=allowed_workspaces,
+            include_legacy_global=include_legacy_global,
+        )
         if conversation_id == "legacy-previous-history":
             return [item for item in history if not item.get("conversation_id")]
         return [item for item in history if item.get("conversation_id") == conversation_id]
 
-    def clear_history(keep_last: int = 0) -> Dict:
-        return CONVERSATIONS.clear_all(keep_last=keep_last)
+    def clear_history(
+        keep_last: int = 0,
+        *,
+        user_email: Optional[str] = None,
+        allowed_workspaces=None,
+        include_legacy_global: Optional[bool] = None,
+    ) -> Dict:
+        if allowed_workspaces is None and user_email:
+            allowed_workspaces = _history_allowed_workspaces_for(user_email)
+        if include_legacy_global is None:
+            include_legacy_global = _history_include_legacy_global(user_email)
+        return CONVERSATIONS.clear_all(
+            keep_last=keep_last,
+            user_email=user_email,
+            allowed_workspaces=allowed_workspaces,
+            include_legacy_global=include_legacy_global,
+        )
 
-    def clear_conversation(conversation_id: str, started_at: Optional[str] = None) -> Dict:
-        return CONVERSATIONS.clear_conversation(conversation_id, started_at=started_at)
+    def clear_conversation(
+        conversation_id: str,
+        started_at: Optional[str] = None,
+        *,
+        user_email: Optional[str] = None,
+        allowed_workspaces=None,
+        include_legacy_global: Optional[bool] = None,
+    ) -> Dict:
+        if allowed_workspaces is None and user_email:
+            allowed_workspaces = _history_allowed_workspaces_for(user_email)
+        if include_legacy_global is None:
+            include_legacy_global = _history_include_legacy_global(user_email)
+        return CONVERSATIONS.clear_conversation(
+            conversation_id,
+            started_at=started_at,
+            user_email=user_email,
+            allowed_workspaces=allowed_workspaces,
+            include_legacy_global=include_legacy_global,
+        )
 
     _access_runtime = build_access_runtime(
         config=CONFIG,
@@ -942,6 +1011,8 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
         ENABLE_GRAPH=ENABLE_GRAPH,
         AUTOLOAD_MODELS=AUTOLOAD_MODELS,
         MODEL_IDLE_UNLOAD_SECONDS=MODEL_IDLE_UNLOAD_SECONDS,
+        ALLOW_MODEL_DOWNLOADS=ALLOW_MODEL_DOWNLOADS,
+        MODEL_DOWNLOAD_TIMEOUT=MODEL_DOWNLOAD_TIMEOUT,
         ALLOW_LOCAL_MODELS=ALLOW_LOCAL_MODELS,
         REQUIRE_AUTH=REQUIRE_AUTH,
         INVITE_GATE_ENABLED=INVITE_GATE_ENABLED,
@@ -1136,6 +1207,7 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
         load_users=load_users,
         get_user_role=get_user_role,
         enforce_rate_limit=enforce_rate_limit,
+        allowed_workspaces_for=_history_allowed_workspaces_for,
         append_audit_event=append_audit_event,
         get_audit_log=get_audit_log,
         get_history=get_history,
@@ -1383,6 +1455,16 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
     return dict(locals())
 
 
+@dataclass(frozen=True)
+class LegacyRuntimeNamespace:
+    """Compatibility adapter for the historical module-level runtime surface."""
+
+    namespace: Dict[str, Any]
+
+    def bind(self, runtime: "AppRuntime") -> None:
+        runtime.__dict__.update(self.namespace)
+
+
 class AppRuntime:
     """The constructed application namespace.
 
@@ -1391,7 +1473,8 @@ class AppRuntime:
     """
 
     def __init__(self, namespace: Dict[str, Any]) -> None:
-        self.__dict__.update(namespace)
+        self._legacy_namespace = LegacyRuntimeNamespace(namespace)
+        self._legacy_namespace.bind(self)
 
 
 _runtime_lock = threading.RLock()

package/latticeai/core/agent.py

@@ -52,7 +52,7 @@ class AgentRunContext:
     """Mutable state carrier passed through all agent phases."""
     __slots__ = ("state", "plan", "transcript", "retry_count",
                  "state_history", "corrections", "final_message", "rollback_log",
-                 "executing_model", "reviewing_model")
+                 "executing_model", "reviewing_model", "approved_by_human")
 
     def __init__(self) -> None:
         self.state:           AgentState   = AgentState.IDLE
@@ -65,6 +65,7 @@ class AgentRunContext:
         self.rollback_log:    list         = []
         self.executing_model: Optional[str] = None
         self.reviewing_model: Optional[str] = None
+        self.approved_by_human: bool       = False
 
 
 def extract_action(raw: str) -> Dict:
@@ -207,7 +208,7 @@ class SingleAgentRuntime:
         ctx.state = AgentState.WAITING_APPROVAL
 
     # ── APPROVAL ─────────────────────────────────────────────────────
-    def approve(self, ctx: AgentRunContext, current_user: str) -> None:
+    def approve(self, ctx: AgentRunContext, current_user: str, *, approved_by_human: bool = False) -> None:
         """APPROVAL: Check governance, log decision, auto-approve (future: UI prompt)."""
         d = self.deps
         auto_approve_tools = {name for name, p in d.tool_governance.items() if p["auto_approve"]}
@@ -219,12 +220,22 @@ class SingleAgentRuntime:
             "state": AgentState.WAITING_APPROVAL.value,
             "requires_approval": requires,
             "non_auto_approve_steps": non_auto,
-            "decision": "auto_approved",
+            "decision": "human_approved" if requires and approved_by_human else ("blocked_pending_approval" if requires else "auto_approved"),
         })
         d.audit(
             "agent_approval", user_email=current_user,
-            requires_approval=requires, non_auto_steps=non_auto, decision="auto_approved",
+            requires_approval=requires,
+            non_auto_steps=non_auto,
+            decision="human_approved" if requires and approved_by_human else ("blocked_pending_approval" if requires else "auto_approved"),
         )
+        if requires and not approved_by_human:
+            ctx.final_message = (
+                "이 작업에는 명시 승인이 필요한 도구가 포함되어 있어 자동 실행을 중단했습니다. "
+                "human_in_loop 승인 흐름으로 다시 실행해 주세요."
+            )
+            ctx.state = AgentState.FAILED
+            return
+        ctx.approved_by_human = bool(approved_by_human)
         ctx.state = AgentState.EXECUTING
 
     # ── EXECUTE ──────────────────────────────────────────────────────
@@ -317,7 +328,7 @@ class SingleAgentRuntime:
                 )
                 continue
 
-            if not policy["auto_approve"]:
+            if not policy["auto_approve"] and not ctx.approved_by_human:
                 d.audit(
                     "agent_exec", user_email=current_user, source=getattr(req, "source", None) or "agent",
                     state=AgentState.EXECUTING.value, action=name, risk=risk,
@@ -326,6 +337,13 @@ class SingleAgentRuntime:
                     rollback=policy["rollback"],
                     args={k: v for k, v in args.items() if k != "content"},
                 )
+                ctx.transcript.append({
+                    "state": AgentState.EXECUTING.value, "action": name,
+                    "thoughts": thoughts, "args": args, "risk": risk,
+                    "governance": dict(policy),
+                    "error": f"BLOCKED: action '{name}' requires explicit approval.",
+                })
+                continue
 
             try:
                 d.check_role(name, current_user)
@@ -422,8 +440,8 @@ class SingleAgentRuntime:
             if gov.get("rollback") != "git":
                 continue
             result = step.get("result", {})
-            if not (isinstance(result, dict) and result.get("success")):
-                continue
+            if not isinstance(result, dict):
+                result = {}
             path = result.get("path") or (step.get("args") or {}).get("path", "")
             if not path:
                 continue

package/latticeai/core/legacy_compatibility.py

@@ -14,7 +14,7 @@ from pathlib import Path
 from typing import Any, Dict, List
 
 
-LEGACY_COMPATIBILITY_VERSION = "8.8.0"
+LEGACY_COMPATIBILITY_VERSION = "8.9.0"
 
 
 @dataclass(frozen=True)

package/latticeai/core/marketplace.py

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

package/latticeai/core/sessions.py

@@ -90,8 +90,16 @@ def _entry_created_at(entry: tuple) -> float:
 
 
 class SessionStore:
-    def __init__(self, data_dir: Optional[Path] = None):
+    def __init__(
+        self,
+        data_dir: Optional[Path] = None,
+        *,
+        ttl_seconds: int = SESSION_TTL,
+        refresh_threshold_seconds: int = SESSION_REFRESH_THRESHOLD,
+    ):
         self._data_dir = data_dir
+        self._ttl_seconds = int(ttl_seconds or SESSION_TTL)
+        self._refresh_threshold_seconds = int(refresh_threshold_seconds or SESSION_REFRESH_THRESHOLD)
         self._sessions: Dict[str, tuple] = load_sessions(data_dir)
 
     def create(self, subject: str, *, email: Optional[str] = None) -> str:
@@ -117,11 +125,11 @@ class SessionStore:
             if entry is None:
                 return None
             created_at = _entry_created_at(entry)
-            if now - created_at > SESSION_TTL:
+            if now - created_at > self._ttl_seconds:
                 self._sessions.pop(key, None)
                 persist_sessions(self._sessions, self._data_dir)
                 return None
-            if now - created_at > SESSION_REFRESH_THRESHOLD:
+            if now - created_at > self._refresh_threshold_seconds:
                 refreshed = (_entry_subject(entry), now, _entry_email(entry))
                 self._sessions[key] = refreshed
                 persist_sessions(self._sessions, self._data_dir)