ltcai 9.9.5 → 10.0.0

package/latticeai/services/evidence_actions.py

@@ -0,0 +1,254 @@
+"""Evidence → action bridge (v9.9.6).
+
+Answers already carry citations and a grounding badge, and clicking a source
+already opens the stored chunk. The loop stopped there: to *use* the evidence
+the user had to retype the request and hope the model retrieved the same
+sources again.
+
+This service closes that gap deterministically. Given the citations an answer
+actually used, it resolves them against the graph and composes ready-to-send,
+evidence-scoped prompts — "이 근거로 요약 만들기", "체크리스트 만들기",
+"문서 파일 만들기", "한 페이지로 만들기". No model runs here: the output is a
+prompt plus the resolved evidence, so the existing chat/file-generation path
+stays the single execution road.
+
+Honesty rules:
+
+* Citations that no longer resolve are reported in ``missing`` — never
+  silently dropped, and never invented.
+* When nothing resolves, ``actions`` is empty and ``reason`` says why. The UI
+  must not offer an action the Brain cannot ground.
+* Every composed prompt tells the model to use only the quoted evidence and
+  to say so when the evidence does not cover the request.
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+from typing import Any, Callable, Dict, List, Mapping, Optional, Sequence
+
+LOGGER = logging.getLogger(__name__)
+
+__all__ = ["EvidenceActionService", "EVIDENCE_ACTIONS"]
+
+# Per-source excerpt cap. Long enough to carry the claim, short enough that a
+# four-citation prompt still fits a small local model's context.
+_EXCERPT_CHARS = 600
+_MAX_SOURCES = 8
+
+
+def _phrase(ko: str, en: str) -> Dict[str, str]:
+    return {"ko": ko, "en": en}
+
+
+# The action catalog is closed and deterministic — the UI renders exactly
+# these, and each one names the artifact it produces.
+EVIDENCE_ACTIONS: List[Dict[str, Any]] = [
+    {
+        "id": "summary",
+        "label": _phrase("이 근거로 요약 만들기", "Summarize from this evidence"),
+        "instruction": _phrase(
+            "핵심만 5줄 이내로 요약해 주세요.",
+            "Summarize the key points in five lines or fewer.",
+        ),
+        "kind": "chat",
+    },
+    {
+        "id": "checklist",
+        "label": _phrase("이 근거로 체크리스트 만들기", "Build a checklist"),
+        "instruction": _phrase(
+            "실행 가능한 체크리스트를 만들어 주세요. 각 항목은 한 줄이고, 근거가 있는 항목만 넣으세요.",
+            "Build an actionable checklist. One line per item, only items the evidence supports.",
+        ),
+        "kind": "chat",
+    },
+    {
+        "id": "document",
+        "label": _phrase("이 근거로 문서 파일 만들기", "Write a document file"),
+        "instruction": _phrase(
+            "정리된 마크다운 문서를 만들어 {path} 파일로 저장해 주세요.",
+            "Write a structured markdown document and save it as {path}.",
+        ),
+        "kind": "file",
+        "extension": ".md",
+    },
+    {
+        "id": "page",
+        "label": _phrase("이 근거로 한 페이지 만들기", "Build a one-page view"),
+        "instruction": _phrase(
+            "내용을 한눈에 보는 HTML 한 페이지로 만들어 {path} 파일로 저장해 주세요.",
+            "Build a single self-contained HTML page and save it as {path}.",
+        ),
+        "kind": "file",
+        "extension": ".html",
+    },
+]
+
+_SLUG_STRIP_RE = re.compile(r"[^a-z0-9]+")
+
+
+def slugify(text: str, *, fallback: str = "evidence-note") -> str:
+    """Deterministic, filesystem-safe stem for a suggested artifact path.
+
+    Non-ASCII text (Korean questions are the common case) leaves nothing to
+    slug — the fallback keeps the suggestion predictable instead of producing
+    a mangled or empty filename.
+    """
+    slug = _SLUG_STRIP_RE.sub("-", str(text or "").lower()).strip("-")
+    slug = "-".join(part for part in slug.split("-") if part)[:48].strip("-")
+    return slug or fallback
+
+
+class EvidenceActionService:
+    """Compose evidence-scoped follow-up actions for an answer's citations."""
+
+    def __init__(
+        self,
+        *,
+        node_reader: Optional[Callable[..., Mapping[str, Any]]] = None,
+        excerpt_chars: int = _EXCERPT_CHARS,
+    ) -> None:
+        self._node_reader = node_reader
+        self._excerpt_chars = max(120, int(excerpt_chars))
+
+    # ── evidence resolution ──────────────────────────────────────────────
+
+    def _read_node(self, node_id: str, allowed_workspaces: Any) -> Optional[Mapping[str, Any]]:
+        if self._node_reader is None:
+            return None
+        try:
+            return self._node_reader(node_id, allowed_workspaces=allowed_workspaces)
+        except TypeError:
+            # Readers without scope support (tests, older ports).
+            try:
+                return self._node_reader(node_id)
+            except Exception as exc:  # noqa: BLE001 — resolution is best-effort
+                LOGGER.debug("evidence node read failed for %s: %s", node_id, exc)
+                return None
+        except Exception as exc:  # noqa: BLE001
+            LOGGER.debug("evidence node read failed for %s: %s", node_id, exc)
+            return None
+
+    def resolve(
+        self,
+        source_ids: Sequence[str],
+        *,
+        allowed_workspaces: Any = None,
+    ) -> Dict[str, Any]:
+        """Resolve citation ids to ``{"sources": [...], "missing": [...]}``."""
+        sources: List[Dict[str, Any]] = []
+        missing: List[str] = []
+        seen: set = set()
+        for raw in list(source_ids or [])[:_MAX_SOURCES]:
+            node_id = str(raw or "").strip()
+            if not node_id or node_id in seen:
+                continue
+            seen.add(node_id)
+            node = self._read_node(node_id, allowed_workspaces)
+            if not isinstance(node, Mapping):
+                missing.append(node_id)
+                continue
+            # /api/graph/node wraps the record; get_node returns it directly.
+            record = node.get("node") if isinstance(node.get("node"), Mapping) else node
+            title = str(record.get("title") or record.get("id") or node_id)
+            body = str(record.get("summary") or record.get("content") or "").strip()
+            metadata = record.get("metadata")
+            metadata = metadata if isinstance(metadata, Mapping) else {}
+            origin = ""
+            for key in ("relative_path", "file_path", "filename", "source_uri", "source"):
+                value = metadata.get(key)
+                if value:
+                    origin = str(value)
+                    break
+            sources.append({
+                "id": node_id,
+                "title": title,
+                "type": str(record.get("type") or ""),
+                "origin": origin,
+                "excerpt": body[: self._excerpt_chars],
+                "truncated": len(body) > self._excerpt_chars,
+            })
+        return {"sources": sources, "missing": missing}
+
+    # ── prompt composition ───────────────────────────────────────────────
+
+    def _evidence_block(self, sources: Sequence[Mapping[str, Any]], language: str) -> str:
+        header = "[근거 자료]" if language == "ko" else "[EVIDENCE]"
+        lines = [header]
+        for index, source in enumerate(sources, start=1):
+            origin = f" ({source['origin']})" if source.get("origin") else ""
+            lines.append(f"{index}. {source['title']}{origin}")
+            excerpt = str(source.get("excerpt") or "").strip()
+            if excerpt:
+                suffix = " …" if source.get("truncated") else ""
+                lines.append(f"   {excerpt}{suffix}")
+        return "\n".join(lines)
+
+    def _guard(self, language: str) -> str:
+        if language == "ko":
+            return (
+                "위 근거 자료에 있는 내용만 사용하세요. 근거에 없는 사실은 지어내지 말고, "
+                "근거가 부족하면 '이 부분은 근거가 없습니다'라고 적으세요."
+            )
+        return (
+            "Use only the evidence quoted above. Do not invent facts that are not in it; "
+            "when the evidence does not cover something, say so explicitly."
+        )
+
+    def actions_for(
+        self,
+        *,
+        question: str = "",
+        source_ids: Sequence[str] = (),
+        language: str = "ko",
+        allowed_workspaces: Any = None,
+    ) -> Dict[str, Any]:
+        """Ready-to-send, evidence-scoped follow-up actions for one answer."""
+        language = "ko" if str(language or "ko").lower().startswith("ko") else "en"
+        resolved = self.resolve(source_ids, allowed_workspaces=allowed_workspaces)
+        sources = resolved["sources"]
+        question_text = str(question or "").strip()
+        if not sources:
+            return {
+                "sources": [],
+                "missing": resolved["missing"],
+                "actions": [],
+                "reason": (
+                    "근거로 쓸 출처를 찾지 못했습니다."
+                    if language == "ko"
+                    else "No usable evidence could be resolved."
+                ),
+            }
+
+        evidence = self._evidence_block(sources, language)
+        guard = self._guard(language)
+        stem = slugify(question_text)
+        actions: List[Dict[str, Any]] = []
+        for spec in EVIDENCE_ACTIONS:
+            path = f"{stem}{spec['extension']}" if spec.get("extension") else ""
+            instruction = spec["instruction"][language].replace("{path}", path)
+            question_line = (
+                (f"원래 질문: {question_text}" if language == "ko" else f"Original question: {question_text}")
+                if question_text
+                else ""
+            )
+            prompt = "\n\n".join(
+                part for part in (evidence, instruction, guard, question_line) if part
+            )
+            action: Dict[str, Any] = {
+                "id": spec["id"],
+                "kind": spec["kind"],
+                "label": dict(spec["label"]),
+                "prompt": prompt,
+                "source_ids": [source["id"] for source in sources],
+            }
+            if path:
+                action["suggested_path"] = path
+            actions.append(action)
+        return {
+            "sources": sources,
+            "missing": resolved["missing"],
+            "actions": actions,
+            "reason": "",
+        }

package/latticeai/services/funnel_metrics.py

@@ -181,30 +181,125 @@ class FunnelMetricsService:
         return round(delta, 1) if delta >= 0 else None
 
     def snapshot(self) -> Dict[str, Any]:
-        """Counters + derived rates for the admin surface."""
+        """Counters + derived rates + actionable alerts for the admin surface."""
         with self._lock:
             counters = {name: int(self._state.get(name) or 0) for name in COUNTER_NAMES}
             firsts = {name: self._state.get(name) for name in _FIRST_NAMES}
+        rates = {
+            "real_file_rate": _rate(
+                counters["real_file_delivered"], counters["file_requests"]
+            ),
+            "code_only_rate": _rate(
+                counters["code_only_responses"], counters["file_requests"]
+            ),
+            "needs_review_rate": _rate(
+                counters["needs_review_runs"], counters["agent_runs"]
+            ),
+            "approval_resume_rate": _rate(
+                counters["approval_resumes"], counters["approval_pauses"]
+            ),
+        }
         return {
             "counters": counters,
             "firsts": firsts,
-            "rates": {
-                "real_file_rate": _rate(
-                    counters["real_file_delivered"], counters["file_requests"]
-                ),
-                "code_only_rate": _rate(
-                    counters["code_only_responses"], counters["file_requests"]
-                ),
-                "needs_review_rate": _rate(
-                    counters["needs_review_runs"], counters["agent_runs"]
-                ),
-                "approval_resume_rate": _rate(
-                    counters["approval_resumes"], counters["approval_pauses"]
-                ),
-            },
+            "rates": rates,
+            "alerts": funnel_alerts(counters, rates),
             "ttfv_seconds": self.ttfv_seconds(),
             "generated_at": _utc_now_iso(),
         }
 
 
-__all__ = ["FunnelMetricsService", "COUNTER_NAMES"]
+# ── alerts (review 2026-07-27 P2 #10) ────────────────────────────────────────
+# The funnel already measured the right things; nothing turned a bad number
+# into a decision, so a regression was only visible to whoever opened the
+# admin page. These thresholds convert rates into named, actionable signals.
+#
+# Minimum samples per rule exist so a single unlucky run never raises an
+# alarm — an alert with n=1 is noise, and noisy alerts get ignored.
+
+REAL_FILE_RATE_FLOOR = 0.95
+CODE_ONLY_RATE_CEILING = 0.05
+NEEDS_REVIEW_RATE_CEILING = 0.25
+APPROVAL_RESUME_RATE_FLOOR = 0.5
+MIN_SAMPLES = 10
+
+
+def _alert(
+    key: str, severity: str, ko: str, en: str, **detail: Any
+) -> Dict[str, Any]:
+    return {"key": key, "severity": severity, "ko": ko, "en": en, **detail}
+
+
+def funnel_alerts(
+    counters: Dict[str, int], rates: Dict[str, Optional[float]]
+) -> list:
+    """Turn funnel rates into named signals a person can act on.
+
+    Pure function of the snapshot — no I/O, no clock — so the thresholds are
+    testable and the same numbers always produce the same alerts. Rules stay
+    silent below :data:`MIN_SAMPLES`: an alert nobody can trust is worse than
+    no alert.
+    """
+    alerts: list = []
+    file_requests = int(counters.get("file_requests") or 0)
+    agent_runs = int(counters.get("agent_runs") or 0)
+    approval_pauses = int(counters.get("approval_pauses") or 0)
+
+    real_file_rate = rates.get("real_file_rate")
+    if file_requests >= MIN_SAMPLES and real_file_rate is not None:
+        if real_file_rate < REAL_FILE_RATE_FLOOR:
+            alerts.append(_alert(
+                "real_file_rate_low", "warning",
+                f"파일 요청 중 실제 파일이 나온 비율이 {real_file_rate:.0%}입니다 "
+                f"(목표 {REAL_FILE_RATE_FLOOR:.0%}). 파일 생성 파이프라인을 확인하세요.",
+                f"Only {real_file_rate:.0%} of file requests produced a real file "
+                f"(target {REAL_FILE_RATE_FLOOR:.0%}). Check the file-generation pipeline.",
+                value=real_file_rate, threshold=REAL_FILE_RATE_FLOOR, samples=file_requests,
+            ))
+
+    code_only_rate = rates.get("code_only_rate")
+    if file_requests >= MIN_SAMPLES and code_only_rate is not None:
+        if code_only_rate > CODE_ONLY_RATE_CEILING:
+            alerts.append(_alert(
+                "code_only_rate_high", "warning",
+                f"파일을 요청했는데 코드/설명만 돌아온 비율이 {code_only_rate:.0%}입니다.",
+                f"{code_only_rate:.0%} of file requests came back as code or prose only.",
+                value=code_only_rate, threshold=CODE_ONLY_RATE_CEILING, samples=file_requests,
+            ))
+
+    needs_review_rate = rates.get("needs_review_rate")
+    if agent_runs >= MIN_SAMPLES and needs_review_rate is not None:
+        if needs_review_rate > NEEDS_REVIEW_RATE_CEILING:
+            alerts.append(_alert(
+                "needs_review_rate_high", "warning",
+                f"에이전트 실행의 {needs_review_rate:.0%}가 '검토 필요'로 끝났습니다. "
+                "더 큰 모델을 쓰거나 요청을 작게 나누세요.",
+                f"{needs_review_rate:.0%} of agent runs ended as NEEDS_REVIEW. "
+                "Use a larger model or split requests into smaller steps.",
+                value=needs_review_rate, threshold=NEEDS_REVIEW_RATE_CEILING, samples=agent_runs,
+            ))
+
+    resume_rate = rates.get("approval_resume_rate")
+    if approval_pauses >= MIN_SAMPLES and resume_rate is not None:
+        if resume_rate < APPROVAL_RESUME_RATE_FLOOR:
+            alerts.append(_alert(
+                "approval_resume_rate_low", "info",
+                f"승인 대기 중 실제로 이어서 실행된 비율이 {resume_rate:.0%}입니다. "
+                "승인 카드가 잘 보이는지 확인하세요.",
+                f"Only {resume_rate:.0%} of paused runs were resumed. "
+                "Check that the approval card is actually reaching users.",
+                value=resume_rate, threshold=APPROVAL_RESUME_RATE_FLOOR, samples=approval_pauses,
+            ))
+
+    if int(counters.get("ingest_completions") or 0) > 0 and not counters.get("recall_successes"):
+        alerts.append(_alert(
+            "no_grounded_recall", "warning",
+            "자료는 들어왔지만 근거 있는 회상이 아직 한 번도 없었습니다. 검색/인덱싱을 확인하세요.",
+            "Content was ingested but no answer has ever been grounded in it yet — "
+            "check retrieval and indexing.",
+            samples=int(counters.get("ingest_completions") or 0),
+        ))
+    return alerts
+
+
+__all__ = ["FunnelMetricsService", "COUNTER_NAMES", "funnel_alerts"]

package/latticeai/services/local_knowledge.py

@@ -293,6 +293,32 @@ def create_local_knowledge_router(
         payload["watch"] = watch_status
         return payload
 
+    @router.get("/knowledge-graph/local/health")
+    async def knowledge_graph_local_health(request: Request, error_samples: int = 3):
+        """Per-folder memory state (v9.9.7): indexing coverage, failures with
+        their stored reasons, and watch state.
+
+        Vector freshness rides along as an explicitly **global** figure — the
+        vector index is not per-folder, and claiming otherwise would invent a
+        number.
+        """
+        require_user(request)
+        kg = graph()
+        payload = kg.local_source_health(error_samples=error_samples)
+        watch_status = watcher.status() if watcher else {"available": False, "active": {}}
+        active = watch_status.get("active", {})
+        for folder in payload.get("folders", []):
+            folder["watch_active"] = folder.get("id") in active
+        payload["watch"] = watch_status
+        try:
+            payload["vector_freshness_global"] = kg.vector_freshness()
+        except Exception as exc:  # noqa: BLE001 — one missing signal, not a 500
+            payload["vector_freshness_global"] = {
+                "status": "unavailable", "detail": str(exc),
+                "pending_items": 0, "total_items": 0,
+            }
+        return payload
+
     @router.get("/knowledge-graph/local/watch/status")
     async def knowledge_graph_local_watch_status(request: Request):
         require_user(request)

package/latticeai/services/memory_service.py

@@ -930,6 +930,15 @@ class MemoryService:
                 similarity = round(float(hit.get("score") or 0.0), 4)
                 if similarity <= 0:
                     continue
+                # Citation precision (v9.9.6): a chunk hit knows where in the
+                # document it came from (section heading / page). Carry that
+                # locator onto the recall row so the citation can say it.
+                hit_metadata = hit.get("metadata")
+                locator = (
+                    str(hit_metadata.get("locator") or "")
+                    if isinstance(hit_metadata, dict)
+                    else ""
+                )
                 existing = by_node_id.get(node_id)
                 if existing is not None:
                     existing["vector_score"] = max(existing.get("vector_score", 0.0), similarity)
@@ -937,6 +946,8 @@ class MemoryService:
                         max(existing.get("score", 0.0), 0.4 * existing.get("score", 0.0) + 0.6 * similarity),
                         4,
                     )
+                    if locator and not existing.get("locator"):
+                        existing["locator"] = locator
                 else:
                     matched = _matched_terms(hit.get("title"), hit.get("summary"))
                     row = {
@@ -948,6 +959,7 @@ class MemoryService:
                         "score": round(max(_lexical_score(matched), 0.6 * similarity), 4),
                         "matched_terms": matched,
                         "vector_score": similarity,
+                        **({"locator": locator} if locator else {}),
                     }
                     results.append(row)
                     if node_id:

package/latticeai/services/permission_mode_service.py

@@ -0,0 +1,170 @@
+"""Persisted permission-mode preference (v9.9.8).
+
+Stores the active mode under the data dir so every surface (web, VS Code,
+Telegram, agent loop) shares one dial. Scope:
+
+* global default (env ``LATTICEAI_PERMISSION_MODE`` or strict)
+* per-user override
+* per-workspace override (wins over user)
+
+Changing to ``bypass`` requires ``acknowledge_risk=True`` once; the ack is
+audited. Circuit breakers are enforced by ``latticeai.core.permission_mode``,
+not by this store.
+"""
+
+from __future__ import annotations
+
+import json
+import threading
+from pathlib import Path
+from typing import Any, Callable, Dict, Optional
+
+from latticeai.core.io_utils import atomic_write_json
+from latticeai.core.permission_mode import (
+    DEFAULT_MODE,
+    PermissionMode,
+    mode_catalog,
+    mode_contract,
+    normalize_mode,
+)
+
+
+class PermissionModeService:
+    """Load / save the autonomy dial."""
+
+    def __init__(
+        self,
+        *,
+        data_dir: Path,
+        default_mode: PermissionMode | str = DEFAULT_MODE,
+        audit: Optional[Callable[..., None]] = None,
+    ) -> None:
+        self._path = Path(data_dir) / "permission_mode.json"
+        self._default = normalize_mode(default_mode)
+        self._audit = audit or (lambda *a, **kw: None)
+        self._lock = threading.Lock()
+
+    def rebind_data_dir(self, data_dir: Path) -> None:
+        """Point the store at the app's real data dir.
+
+        The wiring may instantiate this service lazily before routers know the
+        configured data dir; rebinding keeps one file of record instead of
+        stranding writes under the fallback path.
+        """
+        with self._lock:
+            self._path = Path(data_dir) / "permission_mode.json"
+
+    def rebind_audit(self, audit: Callable[..., None]) -> None:
+        """Attach the real audit sink once app wiring provides one."""
+        with self._lock:
+            self._audit = audit
+
+    def _read(self) -> Dict[str, Any]:
+        if not self._path.exists():
+            return {"default": self._default.value, "users": {}, "workspaces": {}}
+        try:
+            data = json.loads(self._path.read_text(encoding="utf-8"))
+        except Exception:
+            return {"default": self._default.value, "users": {}, "workspaces": {}}
+        if not isinstance(data, dict):
+            return {"default": self._default.value, "users": {}, "workspaces": {}}
+        data.setdefault("default", self._default.value)
+        data.setdefault("users", {})
+        data.setdefault("workspaces", {})
+        return data
+
+    def _write(self, data: Dict[str, Any]) -> None:
+        self._path.parent.mkdir(parents=True, exist_ok=True)
+        atomic_write_json(self._path, data)
+
+    def _resolve_from(
+        self,
+        data: Dict[str, Any],
+        *,
+        user_email: Optional[str],
+        workspace_id: Optional[str],
+    ) -> PermissionMode:
+        """Scope precedence: workspace → user → process default.
+
+        Pure over ``data`` and lock-free, so holders of ``_lock`` can reuse it
+        without re-entering a non-reentrant lock.
+        """
+        if workspace_id:
+            ws = (data.get("workspaces") or {}).get(str(workspace_id))
+            if ws:
+                return normalize_mode(ws)
+        if user_email:
+            user = (data.get("users") or {}).get(str(user_email).lower())
+            if user:
+                return normalize_mode(user)
+        return normalize_mode(data.get("default") or self._default)
+
+    def resolve(
+        self,
+        *,
+        user_email: Optional[str] = None,
+        workspace_id: Optional[str] = None,
+    ) -> PermissionMode:
+        with self._lock:
+            data = self._read()
+        return self._resolve_from(
+            data, user_email=user_email, workspace_id=workspace_id,
+        )
+
+    def get(
+        self,
+        *,
+        user_email: Optional[str] = None,
+        workspace_id: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        mode = self.resolve(user_email=user_email, workspace_id=workspace_id)
+        contract = mode_contract(mode)
+        contract["catalog"] = mode_catalog()
+        contract["scope"] = {
+            "user_email": user_email,
+            "workspace_id": workspace_id,
+        }
+        return contract
+
+    def set_mode(
+        self,
+        mode: PermissionMode | str,
+        *,
+        user_email: Optional[str] = None,
+        workspace_id: Optional[str] = None,
+        acknowledge_risk: bool = False,
+        source: str = "api",
+    ) -> Dict[str, Any]:
+        mode = normalize_mode(mode)
+        if mode == PermissionMode.BYPASS and not acknowledge_risk:
+            raise PermissionError(
+                "bypass mode requires acknowledge_risk=true "
+                "(YOLO inside the agent workspace; circuit breakers still apply)"
+            )
+        with self._lock:
+            data = self._read()
+            # Lock-free helper on purpose: calling ``resolve`` here would
+            # re-enter ``_lock`` and deadlock every mode change.
+            previous = self._resolve_from(
+                data, user_email=user_email, workspace_id=workspace_id,
+            )
+            if workspace_id:
+                data.setdefault("workspaces", {})[str(workspace_id)] = mode.value
+            elif user_email:
+                data.setdefault("users", {})[str(user_email).lower()] = mode.value
+            else:
+                data["default"] = mode.value
+            self._write(data)
+        self._audit(
+            "permission_mode_changed",
+            user_email=user_email,
+            workspace_id=workspace_id,
+            previous=previous.value,
+            mode=mode.value,
+            source=source,
+            acknowledge_risk=bool(acknowledge_risk),
+        )
+        return self.get(user_email=user_email, workspace_id=workspace_id)
+
+
+__all__ = ["PermissionModeService"]

package/latticeai/services/product_readiness.py

@@ -18,7 +18,7 @@ from typing import Any, Dict, List
 
 from latticeai.services.architecture_readiness import architecture_readiness
 
-PRODUCT_VERSION_TARGET = "9.9.5"
+PRODUCT_VERSION_TARGET = "10.0.0"
 
 
 @dataclass(frozen=True)