ltcai 11.5.2 → 11.7.0

package/latticeai/core/run_store.py

@@ -1,252 +0,0 @@
-"""Durable persistence for paused agent runs (review 2026-07-25 Wave 0.1).
-
-The ``awaiting_approval`` loop parked runs in an in-process dict, so a server
-restart between pause and resume turned every outstanding approval into a 404
-("승인하려다 사라짐"). This store writes each paused run to one JSON file under
-the data dir, so a valid, unexpired token can resume its run across restarts
-and across worker processes.
-
-Design constraints (deliberate, matching :mod:`latticeai.services.funnel_metrics`):
-
-* **One JSON file per run**, atomic replace on write — no new dependencies.
-* **Fail-open on save, fail-closed on resume.** A persistence error never
-  breaks the pause response (the in-memory path still works); a load error on
-  resume is treated as "run not found".
-* **Tokens are never stored in plaintext.** Only the SHA-256 hex digest is
-  persisted; resume hashes the presented token and compares digests.
-* **Wall-clock expiry.** The in-memory dict keeps its monotonic deadline, but
-  monotonic time does not survive a restart — the durable record carries an
-  absolute UTC epoch and files past it are swept, never resumed.
-"""
-
-from __future__ import annotations
-
-import json
-import logging
-import os
-import re
-import tempfile
-import time
-from pathlib import Path
-from typing import Any, Dict, List, Optional
-
-from latticeai.core.agent import AgentRunContext, AgentState
-from latticeai.core.agent_trace import LoopTrace
-from latticeai.core.quiet import quiet
-from latticeai.core.security import sha256_hex
-
-LOGGER = logging.getLogger(__name__)
-
-# run_id comes from ``secrets.token_urlsafe`` — validate before any path use
-# so a crafted id can never traverse out of the store directory.
-_RUN_ID_RE = re.compile(r"^[A-Za-z0-9_-]{8,64}$")
-
-
-def hash_approval_token(token: str) -> str:
-    """Stable digest used both at save and at resume comparison time."""
-    return sha256_hex(str(token or ""))
-
-
-def serialize_run_context(ctx: AgentRunContext) -> Dict[str, Any]:
-    """Reduce an :class:`AgentRunContext` to plain JSON-safe data."""
-    return {
-        "state": ctx.state.value,
-        "plan": ctx.plan,
-        "transcript": ctx.transcript,
-        "retry_count": ctx.retry_count,
-        "state_history": ctx.state_history,
-        "corrections": ctx.corrections,
-        "final_message": ctx.final_message,
-        "rollback_log": ctx.rollback_log,
-        "executing_model": ctx.executing_model,
-        "reviewing_model": ctx.reviewing_model,
-        "approved_by_human": ctx.approved_by_human,
-        # A paused run resumes under the dial it was planned and approved with,
-        # not whatever the preference happens to be at resume time.
-        "permission_mode": ctx.permission_mode,
-        "trace": {"events": ctx.trace.events, "truncated": ctx.trace.truncated},
-    }
-
-
-def restore_run_context(payload: Dict[str, Any]) -> AgentRunContext:
-    """Rebuild an :class:`AgentRunContext` from :func:`serialize_run_context`."""
-    ctx = AgentRunContext()
-    try:
-        ctx.state = AgentState(str(payload.get("state") or AgentState.WAITING_APPROVAL.value))
-    except ValueError:
-        ctx.state = AgentState.WAITING_APPROVAL
-    ctx.plan = dict(payload.get("plan") or {})
-    ctx.transcript = list(payload.get("transcript") or [])
-    ctx.retry_count = int(payload.get("retry_count") or 0)
-    ctx.state_history = list(payload.get("state_history") or [])
-    ctx.corrections = list(payload.get("corrections") or [])
-    ctx.final_message = str(payload.get("final_message") or "")
-    ctx.rollback_log = list(payload.get("rollback_log") or [])
-    ctx.executing_model = payload.get("executing_model")
-    ctx.reviewing_model = payload.get("reviewing_model")
-    ctx.approved_by_human = bool(payload.get("approved_by_human"))
-    stored_mode = payload.get("permission_mode")
-    ctx.permission_mode = str(stored_mode) if stored_mode else None
-    trace_payload = payload.get("trace") or {}
-    trace = LoopTrace()
-    trace.events = list(trace_payload.get("events") or [])
-    trace.truncated = int(trace_payload.get("truncated") or 0)
-    ctx.trace = trace
-    return ctx
-
-
-class AgentRunStore:
-    """One-JSON-file-per-run persistence for paused approval runs."""
-
-    def __init__(self, root: Path) -> None:
-        self._root = Path(root)
-
-    def _path_for(self, run_id: str) -> Optional[Path]:
-        if not _RUN_ID_RE.fullmatch(str(run_id or "")):
-            return None
-        return self._root / f"{run_id}.json"
-
-    # ── writes ───────────────────────────────────────────────────────────
-
-    def save(
-        self,
-        run_id: str,
-        *,
-        ctx: AgentRunContext,
-        req_payload: Dict[str, Any],
-        language_hint: str,
-        user: str,
-        token: str,
-        expires_epoch: float,
-        expires_at: str,
-        legacy_context: bool = False,
-    ) -> bool:
-        """Persist a paused run. Best-effort: returns False on any failure."""
-        path = self._path_for(run_id)
-        if path is None:
-            return False
-        record = {
-            "version": 1,
-            "run_id": run_id,
-            "user": user,
-            "language_hint": language_hint,
-            "token_hash": hash_approval_token(token),
-            "expires_epoch": float(expires_epoch),
-            "expires_at": expires_at,
-            "legacy_context": bool(legacy_context),
-            "req": req_payload,
-            "ctx": serialize_run_context(ctx),
-        }
-        try:
-            self._root.mkdir(parents=True, exist_ok=True)
-            fd, tmp_name = tempfile.mkstemp(prefix=path.name, dir=str(self._root))
-            try:
-                with os.fdopen(fd, "w", encoding="utf-8") as handle:
-                    json.dump(record, handle, ensure_ascii=False)
-                os.replace(tmp_name, path)
-            finally:
-                if os.path.exists(tmp_name):
-                    try:
-                        os.unlink(tmp_name)
-                    except OSError:
-                        quiet()
-            return True
-        except Exception as exc:  # noqa: BLE001 — pause must still answer without disk
-            LOGGER.warning("agent run store save failed for %s: %s", run_id, exc)
-            return False
-
-    def delete(self, run_id: str) -> None:
-        path = self._path_for(run_id)
-        if path is None:
-            return
-        try:
-            path.unlink(missing_ok=True)
-        except OSError as exc:
-            LOGGER.warning("agent run store delete failed for %s: %s", run_id, exc)
-
-    # ── reads ────────────────────────────────────────────────────────────
-
-    def load(self, run_id: str) -> Optional[Dict[str, Any]]:
-        """Raw persisted record, or None when missing/corrupt/invalid id."""
-        path = self._path_for(run_id)
-        if path is None:
-            return None
-        try:
-            record = json.loads(path.read_text(encoding="utf-8"))
-        except FileNotFoundError:
-            return None
-        except Exception as exc:  # noqa: BLE001 — corrupt record == not found
-            LOGGER.warning("agent run store load failed for %s: %s", run_id, exc)
-            return None
-        if not isinstance(record, dict) or record.get("run_id") != run_id:
-            return None
-        return record
-
-    def pending_summaries(self, user: Optional[str] = None) -> List[Dict[str, Any]]:
-        """Unexpired pending runs (optionally per user) for surfacing in UI."""
-        summaries: List[Dict[str, Any]] = []
-        now = time.time()
-        try:
-            paths = sorted(self._root.glob("*.json"))
-        except OSError:
-            return summaries
-        for path in paths:
-            try:
-                record = json.loads(path.read_text(encoding="utf-8"))
-            except Exception:  # noqa: BLE001
-                quiet()
-                continue
-            if not isinstance(record, dict):
-                continue
-            if float(record.get("expires_epoch") or 0) <= now:
-                continue
-            if user is not None and record.get("user") != user:
-                continue
-            plan = (record.get("ctx") or {}).get("plan") or {}
-            summaries.append({
-                "run_id": record.get("run_id"),
-                "user": record.get("user"),
-                "goal": str(plan.get("goal") or "")[:200],
-                "expires_at": record.get("expires_at"),
-            })
-        return summaries
-
-    def sweep_expired(
-        self,
-        now_epoch: Optional[float] = None,
-        *,
-        retention_seconds: float = 86400.0,
-    ) -> int:
-        """Remove long-expired run files; returns how many were removed.
-
-        Recently expired records are *kept* for ``retention_seconds`` so that
-        a resume attempt after expiry can still answer 410 with a one-click
-        replan hint (the original request message) instead of a bare 404.
-        """
-        removed = 0
-        now = time.time() if now_epoch is None else float(now_epoch)
-        try:
-            paths = list(self._root.glob("*.json"))
-        except OSError:
-            return removed
-        for path in paths:
-            try:
-                record = json.loads(path.read_text(encoding="utf-8"))
-                expires = float(record.get("expires_epoch") or 0)
-            except Exception:  # noqa: BLE001 — unreadable == expired garbage
-                expires = -float(retention_seconds)
-            if expires + float(retention_seconds) <= now:
-                try:
-                    path.unlink(missing_ok=True)
-                    removed += 1
-                except OSError:
-                    quiet()
-        return removed
-
-
-__all__ = [
-    "AgentRunStore",
-    "hash_approval_token",
-    "restore_run_context",
-    "serialize_run_context",
-]

package/latticeai/core/timezones.py

@@ -1,80 +0,0 @@
-"""Shared timezone helper (피드백 #5 / item 7).
-
-문제: audit 로그 timestamp는 ``datetime.now()`` (시스템 로컬 시간)으로 기록되는데,
-security_dashboard는 "오늘 이벤트 수"를 ``datetime.utcnow().date()`` (UTC) 기준으로
-계산해서 한국 사용자에게 events_today가 어긋났다.
-
-해결: 모든 날짜/시간 기준을 하나의 timezone 헬퍼로 통일한다.
-
-- 환경변수 ``LATTICE_TZ`` (또는 호환용 ``LTCAI_TZ``)가 있으면 그 시간대를 쓴다.
-  예: ``LATTICE_TZ=Asia/Seoul``.
-- 없으면 시스템 로컬 시간대를 쓴다 (기존 audit timestamp와 동일한 기준).
-
-이렇게 하면 "타임스탬프를 쓸 때 쓰는 시간대" === "오늘을 계산할 때 쓰는 시간대" 가
-항상 일치한다.
-"""
-
-from __future__ import annotations
-
-import logging
-import os
-from datetime import datetime, tzinfo
-from typing import Optional
-
-try:  # py3.9+
-    from zoneinfo import ZoneInfo
-except Exception:  # pragma: no cover - 매우 오래된 런타임
-    ZoneInfo = None  # type: ignore
-
-logger = logging.getLogger(__name__)
-
-_TZ_ENV_VARS = ("LATTICE_TZ", "LTCAI_TZ")
-
-
-def _system_local_tz() -> tzinfo:
-    # tz-aware 시스템 로컬 시간대.
-    return datetime.now().astimezone().tzinfo  # type: ignore[return-value]
-
-
-def get_timezone() -> tzinfo:
-    """설정된 시간대를 돌려준다. (환경변수 → 시스템 로컬 순)"""
-    for var in _TZ_ENV_VARS:
-        name = (os.environ.get(var) or "").strip()
-        if not name:
-            continue
-        if ZoneInfo is None:
-            logger.warning("zoneinfo 사용 불가, %s=%s 무시하고 시스템 로컬 사용", var, name)
-            break
-        try:
-            return ZoneInfo(name)
-        except Exception:
-            logger.warning("알 수 없는 시간대 %s=%s, 시스템 로컬로 대체", var, name)
-            break
-    return _system_local_tz()
-
-
-def now(tz: Optional[tzinfo] = None) -> datetime:
-    """설정된 시간대의 현재 시각 (tz-aware)."""
-    return datetime.now(tz or get_timezone())
-
-
-def now_iso(tz: Optional[tzinfo] = None) -> str:
-    """ISO8601 문자열. audit timestamp 기록용."""
-    return now(tz).isoformat()
-
-
-def today_str(tz: Optional[tzinfo] = None) -> str:
-    """오늘 날짜 ``YYYY-MM-DD``. events_today 계산용."""
-    return now(tz).date().isoformat()
-
-
-def tz_name() -> str:
-    """설정된 시간대 이름(있으면 환경변수 값, 없으면 'local')."""
-    for var in _TZ_ENV_VARS:
-        name = (os.environ.get(var) or "").strip()
-        if name:
-            return name
-    return "local"
-
-
-__all__ = ["get_timezone", "now", "now_iso", "today_str", "tz_name"]

package/latticeai/core/workspace_computer_memory.py

@@ -1,84 +0,0 @@
-"""Local Computer Memory: the opt-in that lets the Brain watch this machine.
-
-Extracted from ``WorkspaceOSStore``. Off by default and impossible to enable
-without a recorded consent — the check lives here so there is one place to read
-when asking "what did this machine agree to observe".
-"""
-
-from __future__ import annotations
-
-from typing import Any, Dict, List, Optional
-
-from .timeutil import now_iso as _now
-from .workspace_os_utils import _json_hash
-
-__all__ = ["WorkspaceComputerMemory", "DEFAULT_COMPUTER_MEMORY_SCOPES"]
-
-#: Folders the feature offers to watch when the person names none. Chosen to be
-#: recognisable rather than exhaustive: the point of the list is that a person
-#: reading the consent dialog knows what it means.
-DEFAULT_COMPUTER_MEMORY_SCOPES = ("Downloads", "Documents", "Repositories")
-
-
-class WorkspaceComputerMemory:
-    """Consent state and activity log for watching the local computer."""
-
-    def __init__(self, store: Any) -> None:
-        self.store = store
-
-    def configure(
-        self,
-        *,
-        enabled: bool,
-        approved_by: Optional[str],
-        consent: Optional[Dict[str, Any]] = None,
-        scopes: Optional[List[str]] = None,
-    ) -> Dict[str, Any]:
-        consent = consent or {}
-        if enabled and not consent.get("approved"):
-            raise PermissionError("Local Computer Memory requires explicit approval.")
-        state = self.store.load_state()
-        config = state.setdefault("computer_memory", {})
-        config.update({
-            "enabled": bool(enabled),
-            "approved": bool(enabled),
-            "approved_at": _now() if enabled else config.get("approved_at"),
-            "approved_by": approved_by if enabled else config.get("approved_by"),
-            "scopes": scopes or config.get("scopes") or list(DEFAULT_COMPUTER_MEMORY_SCOPES),
-            "consent": consent,
-        })
-        state.setdefault("feature_flags", {})["local_computer_memory"] = bool(enabled)
-        self.store.save_state(state)
-        self.store.record_timeline_event(
-            "memory",
-            "computer_memory_configured",
-            {"enabled": bool(enabled), "approved_by": approved_by},
-        )
-        return config
-
-    def record_activity(self, activity: Dict[str, Any], graph: Any = None) -> Dict[str, Any]:
-        state = self.store.load_state()
-        config = state.setdefault("computer_memory", {})
-        if not config.get("enabled"):
-            return {"status": "ignored", "reason": "local computer memory is disabled"}
-        record = {
-            "id": f"activity-{_json_hash([activity, _now()])[:16]}",
-            "timestamp": _now(),
-            **activity,
-        }
-        config.setdefault("activities", []).append(record)
-        if graph is not None:
-            # A graph that refuses the event must not lose the activity: the
-            # record is kept either way and carries the reason it did not land.
-            try:
-                graph.ingest_event(
-                    "ComputerActivity",
-                    str(activity.get("summary") or activity.get("path") or "Computer activity")[:120],
-                    source="workspace_os",
-                    metadata=record,
-                )
-            except Exception as exc:
-                record["graph_error"] = str(exc)
-        self.store.save_state(state)
-        self.store.record_timeline_event("memory", "computer_activity", {"activity_id": record["id"]})
-        return {"status": "ok", "activity": record}

package/latticeai/core/workspace_graph_trace.py

@@ -1,155 +0,0 @@
-"""Graph answer trace persistence extracted from WorkspaceOSStore."""
-from __future__ import annotations
-
-from typing import Any, Dict, List, Optional
-
-from latticeai.core.quiet import quiet
-
-from .timeutil import now_iso as _now
-from .workspace_os_utils import WorkspaceStoreMixin, _json_hash, _listify
-
-
-class WorkspaceGraphTrace(WorkspaceStoreMixin):
-    def build_graph_trace(
-        self,
-        question: str,
-        graph: Any,
-        context: str = "",
-        *,
-        limit: int = 8,
-        allowed_workspaces=None,
-    ) -> Dict[str, Any]:
-        if graph is None:
-            return {
-                "source_files": [],
-                "graph_nodes": [],
-                "graph_edges": [],
-                "confidence": 0.0,
-                "retrieval_metadata": {
-                    "query": question,
-                    "matched_nodes": 0,
-                    "graph_enabled": False,
-                    "context_chars": len(context or ""),
-                },
-            }
-
-        matches: List[Dict[str, Any]] = []
-        search_error = ""
-        try:
-            scope_kwargs = (
-                {"allowed_workspaces": allowed_workspaces}
-                if allowed_workspaces is not None
-                else {}
-            )
-            matches = graph.search(
-                question,
-                limit=limit,
-                **scope_kwargs,
-            ).get("matches", [])
-        except Exception as exc:
-            search_error = str(exc)
-            matches = []
-
-        source_files: List[Dict[str, Any]] = []
-        seen_sources = set()
-        for match in matches:
-            meta = match.get("metadata") or {}
-            source = (
-                meta.get("relative_path")
-                or meta.get("file_path")
-                or meta.get("filename")
-                or meta.get("blob_path")
-                or meta.get("source")
-            )
-            if source and source not in seen_sources:
-                seen_sources.add(source)
-                source_files.append({
-                    "source": source,
-                    "node_id": match.get("id"),
-                    "node_title": match.get("title"),
-                    "node_type": match.get("type"),
-                    "jump": {
-                        "graph": f"/graph?node={match.get('id')}",
-                        "source": source,
-                    },
-                })
-
-        edges: List[Dict[str, Any]] = []
-        edge_seen = set()
-        for match in matches[:5]:
-            node_id = match.get("id")
-            if not node_id:
-                continue
-            try:
-                for edge in graph.neighbors(
-                    node_id,
-                    **scope_kwargs,
-                ).get("edges", []):
-                    key = (edge.get("from"), edge.get("to"), edge.get("type"))
-                    if key in edge_seen:
-                        continue
-                    edge_seen.add(key)
-                    edges.append(edge)
-                    if len(edges) >= 24:
-                        break
-            except Exception:
-                quiet()
-                continue
-
-        if matches:
-            confidence = min(0.95, 0.35 + min(len(matches), limit) / max(limit, 1) * 0.45 + (0.10 if edges else 0.0))
-        else:
-            confidence = 0.05 if context else 0.0
-
-        return {
-            "source_files": source_files,
-            "graph_nodes": matches,
-            "graph_edges": edges,
-            "confidence": round(confidence, 4),
-            "retrieval_metadata": {
-                "query": question,
-                "matched_nodes": len(matches),
-                "matched_edges": len(edges),
-                "graph_enabled": True,
-                "context_chars": len(context or ""),
-                "search_error": search_error,
-            },
-        }
-
-    def record_trace(
-        self,
-        *,
-        question: str,
-        response: str,
-        conversation_id: Optional[str],
-        user_email: Optional[str],
-        trace: Dict[str, Any],
-        workspace_id: Optional[str] = None,
-    ) -> Dict[str, Any]:
-        state = self.load_state()
-        trace_id = f"trace-{_json_hash([question, response, conversation_id, _now()])[:16]}"
-        record = {
-            "id": trace_id,
-            "question": question,
-            "response_preview": str(response or "")[:700],
-            "conversation_id": conversation_id,
-            "user_email": user_email,
-            "workspace_id": self._resolve_scope(workspace_id, state),
-            "created_at": _now(),
-            **trace,
-        }
-        state.setdefault("traces", []).append(record)
-        self.save_state(state)
-        self.record_timeline_event(
-            "graph",
-            "answer_trace",
-            {"trace_id": trace_id, "conversation_id": conversation_id},
-            workspace_id=record["workspace_id"],
-        )
-        return record
-
-    def list_traces(self, conversation_id: Optional[str] = None, limit: int = 50, workspace_id: Optional[str] = None) -> Dict[str, Any]:
-        traces = self._scoped(_listify(self.load_state().get("traces")), workspace_id)
-        if conversation_id:
-            traces = [trace for trace in traces if trace.get("conversation_id") == conversation_id]
-        return {"traces": list(reversed(traces[-max(1, min(limit, 200)):]))}

package/latticeai/core/workspace_indexing.py

@@ -1,102 +0,0 @@
-"""Indexing dashboard and per-source watch control.
-
-Extracted from ``WorkspaceOSStore`` so the store stays a façade over composed
-managers rather than a class that also knows how a file watcher reports itself.
-Everything here reads the graph and the watcher and writes only timeline
-events, so it needs the store for ``record_timeline_event`` and nothing else.
-"""
-
-from __future__ import annotations
-
-from typing import Any, Dict, Optional
-
-__all__ = ["WorkspaceIndexing"]
-
-
-class WorkspaceIndexing:
-    """Reads index state out of the graph; pauses, resumes, and removes sources."""
-
-    def __init__(self, store: Any) -> None:
-        self.store = store
-
-    def build_dashboard(
-        self,
-        graph: Any,
-        watcher_status: Optional[Dict[str, Any]] = None,
-    ) -> Dict[str, Any]:
-        if graph is None:
-            return {
-                "sources": [],
-                "watcher": watcher_status or {"available": False, "active": {}},
-                "totals": {"success": 0, "failed": 0, "nodes": 0, "edges": 0},
-            }
-        stats = graph.stats()
-        sources = graph.local_sources().get("sources", [])
-        watcher_status = watcher_status or {"available": False, "active": {}}
-        active = watcher_status.get("active", {})
-        dashboard_sources = []
-        total_success = 0
-        total_failed = 0
-        for source in sources:
-            file_status = source.get("file_status") or {}
-            success = int(file_status.get("indexed") or 0)
-            failed = sum(
-                int(file_status.get(key) or 0)
-                for key in ("failed", "inaccessible", "skipped_empty_text")
-            )
-            total_success += success
-            total_failed += failed
-            watch = active.get(source.get("id")) or {}
-            dashboard_sources.append({
-                "id": source.get("id"),
-                "label": source.get("label"),
-                "root_path": source.get("root_path"),
-                "status": source.get("status"),
-                "watch_enabled": bool(source.get("watch_enabled")),
-                "watch_active": source.get("id") in active,
-                "watch_status": watch,
-                "success_count": success,
-                "failure_count": failed,
-                "last_run_at": source.get("last_scanned_at") or source.get("updated_at"),
-                "file_status": file_status,
-                "include_ocr": bool(source.get("include_ocr")),
-            })
-        return {
-            "sources": dashboard_sources,
-            "watcher": watcher_status,
-            "totals": {
-                "success": total_success,
-                "failed": total_failed,
-                "nodes": sum(int(v or 0) for v in (stats.get("nodes") or {}).values()),
-                "edges": sum(int(v or 0) for v in (stats.get("edges") or {}).values()),
-                "local_sources": stats.get("local_sources", len(sources)),
-            },
-            "graph_stats": stats,
-        }
-
-    def pause(self, graph: Any, source_id: str, watcher: Any = None) -> Dict[str, Any]:
-        result = graph.set_local_source_watch(source_id, False)
-        watch = watcher.stop_source(source_id) if watcher else {"stopped": False, "source_id": source_id}
-        self.store.record_timeline_event("graph", "indexing_paused", {"source_id": source_id})
-        return {"status": "ok", "source": result, "watch": watch}
-
-    def resume(self, graph: Any, source_id: str, watcher: Any = None) -> Dict[str, Any]:
-        result = graph.set_local_source_watch(source_id, True)
-        watch = {"watching": False, "source_id": source_id}
-        source = next(
-            (item for item in graph.local_sources().get("sources", []) if item.get("id") == source_id),
-            None,
-        )
-        if watcher and source:
-            watch = watcher.start_source(source)
-        self.store.record_timeline_event("graph", "indexing_resumed", {"source_id": source_id})
-        return {"status": "ok", "source": result, "watch": watch}
-
-    def remove_source(self, graph: Any, source_id: str, watcher: Any = None) -> Dict[str, Any]:
-        if watcher:
-            watcher.stop_source(source_id)
-        if not hasattr(graph, "remove_local_source"):
-            raise ValueError("graph store does not support removing local sources")
-        result = graph.remove_local_source(source_id)
-        self.store.record_timeline_event("graph", "indexing_removed", {"source_id": source_id})
-        return {"status": "ok", **result}