ltcai 10.6.3 → 10.8.0

package/docs/ONBOARDING.md

@@ -1,6 +1,6 @@
 # Lattice AI Onboarding
 
-Current release: **10.6.3 — Ask First**.
+Current release: **10.8.0 — Within Reach**.
 
 The first-run goal is a five-minute path from "I opened the app" to "my Brain
 has a source, a question, and proof." This page is the product contract behind

package/docs/OPERATIONS.md

@@ -1,4 +1,4 @@
-# Lattice AI — Operations Guide (v10.6.3)
+# Lattice AI — Operations Guide (v10.8.0)
 
 > **Status: canonical** — kept in sync with the current release. Storage layout
 > below reflects the SQLite live Brain store and workspace scoping, not the
@@ -162,3 +162,31 @@ Ctrl+C  또는  kill <pid>
 ```
 
 서버는 종료 시 진행 중인 HTTP 요청을 완료한 후 종료됩니다 (graceful shutdown — uvicorn 기본 동작).
+
+## 10. 릴리스 증거 캡처 순서 (레이아웃·UI 변경 후)
+
+`scripts/capture_release_evidence.mjs` 의 `assertNotOverwritingTaggedRelease()` 는
+`package.json` 버전과 동일한 git 태그(`vX.Y.Z`)가 이미 있으면 **즉시 exit 1** 한다.
+레이아웃/UI를 바꾼 뒤 스크린샷을 다시 찍을 때는 반드시 아래 순서를 지킨다.
+
+1. **버전 범프 먼저** — `node scripts/run_python.mjs scripts/bump_version.py`
+   (또는 동등한 package/pyproject/extension 버전 일괄 상향). 캡처 **전에** 한다.
+2. `npm run build:assets` — 캡처는 빌드된 `static/app` 을 본다.
+3. `npm run release:evidence` — `output/release/v<새버전>/` 에만 기록한다.
+   캡처 → 오래된 버전 정리 → **픽셀 델타 검사**까지 한 번에 돈다.
+4. 결속 검사 — `SCREENSHOT_INDEX.md` 의 `asset-manifest.sha256` 과
+   `mock-server.sha256` 이 각각 `static/app/asset-manifest.json`,
+   `tests/visual/mock_server.cjs` 와 일치해야 `npm run lint` 가 통과한다.
+
+레이아웃을 바꿨다고 보고했는데 배치는 그대로인 경우를 잡기 위해 v10.7.0 부터
+`scripts/check_screenshot_pixel_delta.py` 가 12개 캡처를 직전 버전과 대조한다
+(`npm run check:screenshot-delta` 로 단독 실행). 정적 화면은 1.5%, 애니메이션이
+있는 화면은 8% 이상 픽셀이 달라져야 통과한다. 문구만 고친 화면은 여기서 실패로
+잡히므로, 실패했다면 캡처가 아니라 레이아웃을 다시 본다. 직전 버전 디렉터리가
+정리되어 없으면 기준선을 꺼낼 태그를 체크아웃한 뒤 다시 돌린다.
+
+이미 태그가 찍힌 버전의 `output/release/vX.Y.Z/` 를 WIP UI로 덮으면 그 릴리스
+증거가 영구히 거짓이 된다. 미리보기만 필요하면
+`LTCAI_RELEASE_EVIDENCE_DIR=/tmp/lattice-preview npm run release:evidence` 로
+게시 경로 밖을 쓴다. 태그된 버전의 원본 증거가 오염됐다면 태그 시점 트리에서
+해당 디렉터리를 복원한 뒤, 새 버전 디렉터리에 다시 캡처한다.

package/docs/TRUST_MODEL.md

@@ -1,6 +1,6 @@
 # Lattice AI Trust Model
 
-Current release: **10.6.3 — Ask First**.
+Current release: **10.8.0 — Within Reach**.
 
 Lattice AI is local-first, explicit about external communication, and honest
 when a capability is unavailable.

package/docs/WHY_LATTICE.md

@@ -1,6 +1,6 @@
 # Why Lattice AI Exists
 
-Current release: **10.6.3 — Ask First**.
+Current release: **10.8.0 — Within Reach**.
 
 **Lattice AI is a local-first Digital Brain that keeps your knowledge durable
 across any AI model.**

package/docs/kg-schema.md

@@ -1,6 +1,6 @@
 # Knowledge Graph Schema
 
-Current release: **10.6.3 — Ask First**.
+Current release: **10.8.0 — Within Reach**.
 
 명세 출처: `lattice_ai_full_spec.pptx` 슬라이드 20·21·22
 구현: `lattice_brain/graph/schema.py`

package/lattice_brain/__init__.py

@@ -26,7 +26,7 @@ from .storage import (
     storage_from_env,
 )
 
-__version__ = "10.6.3"
+__version__ = "10.8.0"
 
 __all__ = [
     "AgentRuntime",

package/lattice_brain/graph/retrieval_vector.py

@@ -136,14 +136,45 @@ class KnowledgeGraphVectorMixin(_Core):
         )
         return {"current": current, "recorded": recorded, "stale_embedder": stale}
 
+    def _vector_text_hashes(self, conn: sqlite3.Connection) -> Dict[str, str]:
+        """``item_id -> text_hash`` for rows already embedded by *this* embedder.
+
+        The incremental rebuild's job is mostly deciding what it does *not*
+        have to do, and it used to ask that question with one ``SELECT`` per
+        candidate item — a round trip per node and per chunk on every run,
+        almost all of which answer "unchanged". One query returning two short
+        columns replaces all of them.
+
+        Rows written by a different embedder are left out, so they compare as
+        missing and get re-embedded, which is what an embedder swap requires.
+        """
+        return {
+            row["item_id"]: row["text_hash"]
+            for row in conn.execute(
+                """
+                    SELECT item_id, text_hash
+                    FROM vector_embeddings
+                    WHERE embedding_model=? AND embedding_dim=?
+                    """,
+                (self._embedding_model.model_id, self._embedding_model.dim),
+            ).fetchall()
+        }
+
     def _iter_vector_source_items(
         self,
         conn: sqlite3.Connection,
         *,
         include_nodes: bool = True,
         include_chunks: bool = True,
-    ) -> List[Dict[str, Any]]:
-        items: List[Dict[str, Any]] = []
+    ) -> Iterator[Dict[str, Any]]:
+        """Stream the graph's embeddable text, one item at a time.
+
+        Yields rather than returns a list. Every caller consumes this exactly
+        once in a ``for``, and building the list first meant a rebuild held
+        the full text of every node and chunk in memory simultaneously — the
+        one shape guaranteed to fail on precisely the large graph that most
+        needs the index.
+        """
         if include_nodes:
             for row in conn.execute(
                 """
@@ -160,15 +191,13 @@ class KnowledgeGraphVectorMixin(_Core):
                     metadata=metadata,
                 )
                 if text:
-                    items.append(
-                        {
-                            "item_id": row["id"],
-                            "item_type": "node",
-                            "source_node": row["id"],
-                            "text": text,
-                            "metadata": {"node_type": row["type"], **metadata},
-                        }
-                    )
+                    yield {
+                        "item_id": row["id"],
+                        "item_type": "node",
+                        "source_node": row["id"],
+                        "text": text,
+                        "metadata": {"node_type": row["type"], **metadata},
+                    }
         if include_chunks:
             for row in conn.execute(
                 """
@@ -181,19 +210,16 @@ class KnowledgeGraphVectorMixin(_Core):
                 metadata = _safe_loads(row["metadata_json"])
                 text = _clean_text(row["text"] or "")
                 if text:
-                    items.append(
-                        {
-                            "item_id": row["id"],
-                            "item_type": "chunk",
-                            "source_node": row["id"],
-                            "text": text,
-                            "metadata": {
-                                **metadata,
-                                "parent_source_node": row["parent_source_node"],
-                            },
-                        }
-                    )
-        return items
+                    yield {
+                        "item_id": row["id"],
+                        "item_type": "chunk",
+                        "source_node": row["id"],
+                        "text": text,
+                        "metadata": {
+                            **metadata,
+                            "parent_source_node": row["parent_source_node"],
+                        },
+                    }
 
     def index_node_incremental(self, node_id: str) -> Dict[str, Any]:
         """Embed/index only ``node_id`` and its chunks (incremental sync).
@@ -345,15 +371,22 @@ class KnowledgeGraphVectorMixin(_Core):
                         conn.execute(
                             f"DELETE FROM vector_embeddings WHERE item_type IN ({','.join(filters)})"
                         )
-                items = self._iter_vector_source_items(
+                # After a full wipe nothing is current by definition, so the
+                # prefetch would only be a wasted scan of a table we just
+                # emptied. Incremental is where it pays: it turns "one SELECT
+                # per item, nearly all of which say unchanged" into one query.
+                known = {} if full else self._vector_text_hashes(conn)
+                total = indexed = skipped = 0
+                for item in self._iter_vector_source_items(
                     conn,
                     include_nodes=include_nodes,
                     include_chunks=include_chunks,
-                )
-                indexed = skipped = 0
-                for item in items:
-                    changed = self._upsert_vector_item(conn, **item)
-                    if changed:
+                ):
+                    total += 1
+                    if known.get(item["item_id"]) == _sha256_text(_clean_text(item["text"])):
+                        skipped += 1
+                        continue
+                    if self._upsert_vector_item(conn, **item):
                         indexed += 1
                     else:
                         skipped += 1
@@ -367,7 +400,7 @@ class KnowledgeGraphVectorMixin(_Core):
                         """,
                     (
                         _now(),
-                        len(items),
+                        total,
                         indexed,
                         skipped,
                         _json(
@@ -390,7 +423,7 @@ class KnowledgeGraphVectorMixin(_Core):
                 "status": "completed",
                 "operation_id": op_id,
                 "full": bool(full),
-                "items_total": len(items),
+                "items_total": total,
                 "items_indexed": indexed,
                 "items_skipped": skipped,
                 "duration_ms": duration_ms,
@@ -442,7 +475,10 @@ class KnowledgeGraphVectorMixin(_Core):
                     "SELECT item_type, COUNT(*) AS count FROM vector_embeddings GROUP BY item_type"
                 )
             }
-            source_items = self._iter_vector_source_items(conn)
+            # Materialised on purpose, unlike the rebuild path: status walks
+            # this set twice (once for ids, once to classify each item) and
+            # reports a count, none of which a one-shot iterator can serve.
+            source_items = list(self._iter_vector_source_items(conn))
             vector_rows = {
                 row["item_id"]: row
                 for row in conn.execute(

package/lattice_brain/runtime/multi_agent.py

@@ -41,13 +41,15 @@ orchestrator for the product ``/agents`` surface.
 
 from __future__ import annotations
 
+import json
+import re
 from dataclasses import dataclass, field
 from typing import Any, Callable, Dict, List, Optional
 
 from ..utils import now_iso as _now
 from .contracts import multi_agent_contract
 
-MULTI_AGENT_VERSION = "10.6.3"
+MULTI_AGENT_VERSION = "10.8.0"
 
 AGENT_ROLES = ("researcher", "planner", "executor", "reviewer", "release")
 CORE_PIPELINE = ("planner", "executor", "reviewer")
@@ -448,23 +450,102 @@ def default_role_runner(
     return runner
 
 
+def _json_object_candidates(text: str) -> List[str]:
+    """Every balanced ``{...}`` span in ``text``, outermost first.
+
+    ``find("{")`` to ``rfind("}")`` is one span, and it is the wrong one
+    whenever the model wrote anything after its object — a closing remark, a
+    second example, a stray ``}`` in prose — because the slice then contains
+    the object *and* the noise, and parses as neither. Scanning for balance
+    yields the actual objects, in the order they appear.
+
+    String literals are tracked so a brace inside ``"a } b"`` does not close a
+    span early.
+    """
+    spans: List[str] = []
+    depth = 0
+    start = -1
+    in_string = False
+    escaped = False
+    for index, char in enumerate(text):
+        if in_string:
+            if escaped:
+                escaped = False
+            elif char == "\\":
+                escaped = True
+            elif char == '"':
+                in_string = False
+            continue
+        if char == '"':
+            in_string = True
+        elif char == "{":
+            if depth == 0:
+                start = index
+            depth += 1
+        elif char == "}":
+            if depth:
+                depth -= 1
+                if depth == 0 and start >= 0:
+                    spans.append(text[start : index + 1])
+    return spans
+
+
+#: A comma directly before a closing brace/bracket. Small local models emit
+#: these constantly — it is the single most common reason an otherwise correct
+#: plan is thrown away.
+_TRAILING_COMMA_RE = re.compile(r",(\s*[}\]])")
+
+#: Reasoning models wrap their scratchpad in these, and the scratchpad is full
+#: of braces. Removed before anything else so it cannot poison a span.
+_THINK_BLOCK_RE = re.compile(
+    r"<(think|thinking|reasoning|reflection)>.*?</\1>",
+    re.DOTALL | re.IGNORECASE,
+)
+_THINK_OPEN_RE = re.compile(r"<(think|thinking|reasoning)>.*\Z", re.DOTALL | re.IGNORECASE)
+
+
 def _extract_json_object(raw: str) -> Dict[str, Any]:
-    """Parse one JSON object out of an LLM response (fences/prose tolerated)."""
-    import json as _json
-    import re as _re
+    """Parse one JSON object out of an LLM response (fences/prose tolerated).
 
+    Recovery only — never invention. Every strategy here returns something the
+    model actually wrote; when none of them parse, this still raises and the
+    run fails loudly with the raw output preserved, exactly as before. The
+    point is that a 1–4B model's plan should not be discarded over a trailing
+    comma or a farewell sentence.
+    """
     text = str(raw or "").strip()
-    fenced = _re.search(r"```(?:json)?\s*(\{.*?\})\s*```", text, flags=_re.DOTALL)
-    if fenced:
-        text = fenced.group(1)
-    elif not text.startswith("{"):
-        start, end = text.find("{"), text.rfind("}")
-        if start >= 0 and end > start:
-            text = text[start : end + 1]
-    parsed = _json.loads(text)
-    if not isinstance(parsed, dict):
-        raise ValueError("model returned JSON that is not an object")
-    return parsed
+    text = _THINK_BLOCK_RE.sub("", text)
+    text = _THINK_OPEN_RE.sub("", text).strip()
+
+    candidates: List[str] = []
+    for fenced in re.findall(r"```(?:json)?\s*(\{.*?\})\s*```", text, flags=re.DOTALL):
+        candidates.append(fenced)
+    candidates.extend(_json_object_candidates(text))
+    if text.startswith("{"):
+        candidates.append(text)
+
+    last_error: Optional[Exception] = None
+    empty_fallback: Optional[Dict[str, Any]] = None
+    for candidate in candidates:
+        for attempt in (candidate, _TRAILING_COMMA_RE.sub(r"\1", candidate)):
+            try:
+                parsed = json.loads(attempt)
+            except ValueError as exc:
+                last_error = exc
+                continue
+            if not isinstance(parsed, dict):
+                last_error = ValueError("model returned JSON that is not an object")
+                continue
+            if parsed:
+                return parsed
+            # A prose aside like "I considered using { } notation" is a
+            # syntactically valid empty object, and taking the first thing that
+            # parses handed that back as the plan. An empty object is only ever
+            # the answer when nothing else in the reply is one.
+            empty_fallback = parsed
+    if empty_fallback is not None:
+        return empty_fallback
+    raise last_error or ValueError("model returned no JSON object")
 
 
 def llm_role_runner(

package/latticeai/__init__.py

@@ -1,3 +1,3 @@
 """Lattice AI - modular server package."""
 
-__version__ = "10.6.3"
+__version__ = "10.8.0"

package/latticeai/api/admin.py

@@ -5,9 +5,10 @@ from collections import defaultdict
 from datetime import datetime, timedelta
 from typing import Any, Callable, Dict, List, Optional
 
-from fastapi import APIRouter, HTTPException, Query, Request
+from fastapi import APIRouter, Query, Request
 from pydantic import BaseModel
 
+from latticeai.core.messages import http_error, resolve_language
 from latticeai.core.workspace_os import DEFAULT_WORKSPACE_ID
 
 
@@ -159,6 +160,78 @@ def create_admin_router(
             "last_message_at": history[-1].get("timestamp") if history else None,
         }
 
+    @router.get("/admin/health-summary")
+    async def admin_health_summary(request: Request):
+        """One-line admin health for the calm console header (layout rebuild).
+
+        Aggregates existing admin surfaces — no new persistence. ``status`` is
+        ``attention`` when any issue is present, else ``ok``.
+        """
+        _, users = require_admin(request)
+        issues: List[Dict[str, Any]] = []
+
+        disabled = sum(1 for user in users.values() if user.get("disabled"))
+        if disabled:
+            issues.append({
+                "area": "users",
+                "severity": "warning",
+                "message": f"{disabled} disabled user(s)",
+            })
+
+        try:
+            report = build_sensitivity_report(_scoped_history(request)) or {}
+            severity = ((report.get("summary") or {}).get("severity_counts") or {})
+            high = int(severity.get("high") or 0)
+            if high:
+                issues.append({
+                    "area": "security",
+                    "severity": "high",
+                    "message": f"{high} high-risk event(s)",
+                })
+        except Exception as exc:
+            logging.warning("admin health-summary sensitivity failed: %s", exc)
+
+        if enable_graph:
+            try:
+                stats = get_graph_stats() or {}
+                if isinstance(stats, dict) and stats.get("error"):
+                    issues.append({
+                        "area": "brain_ops",
+                        "severity": "warning",
+                        "message": "Knowledge graph unavailable",
+                    })
+            except Exception as exc:
+                issues.append({
+                    "area": "brain_ops",
+                    "severity": "warning",
+                    "message": str(exc)[:160],
+                })
+
+        if product_hardening_status is not None:
+            try:
+                res = product_hardening_status()
+                hardening = res if isinstance(res, dict) else {}
+                startup = hardening.get("startup") if isinstance(hardening, dict) else {}  # type: ignore[union-attr]
+                if isinstance(startup, dict) and startup.get("network_exposed"):
+                    issues.append({
+                        "area": "runtime_trust",
+                        "severity": "warning",
+                        "message": "Server is network-exposed",
+                    })
+            except Exception as exc:
+                logging.warning("admin health-summary hardening failed: %s", exc)
+
+        # issue_count is a first-class field (not client-derived from issues[]).
+        # AdminConsole reads healthData.issue_count for the header sentence;
+        # falling back to || 1 when the field is missing misreports multi-issue
+        # states as a single problem.
+        issue_count = len(issues)
+        return {
+            "status": "attention" if issue_count else "ok",
+            "issue_count": issue_count,
+            "issues": issues,
+        }
+
     @router.get("/admin/stats")
     async def admin_stats(request: Request):
         require_admin(request)
@@ -319,17 +392,18 @@ def create_admin_router(
 
     @router.patch("/admin/users/{email:path}")
     async def admin_update_user(email: str, req: AdminUserUpdate, request: Request):
+        lang = resolve_language(request)
         admin_email, users = require_admin(request)
         if email not in users:
-            raise HTTPException(status_code=404, detail="사용자를 찾을 수 없습니다.")
+            raise http_error(404, "auth.user_not_found", lang)
         before = public_user(email, users[email], users)
         if req.role is not None:
             if req.role not in {"admin", "user"}:
-                raise HTTPException(status_code=400, detail="role은 admin 또는 user만 가능합니다.")
+                raise http_error(400, "admin.invalid_role", lang)
             users[email]["role"] = req.role
         if req.disabled is not None:
             if email == admin_email and req.disabled:
-                raise HTTPException(status_code=400, detail="자기 자신은 비활성화할 수 없습니다.")
+                raise http_error(400, "admin.cannot_disable_self", lang)
             users[email]["disabled"] = req.disabled
         save_users(users)
         after = public_user(email, users[email], users)
@@ -338,11 +412,12 @@ def create_admin_router(
 
     @router.delete("/admin/users/{email:path}")
     async def admin_delete_user(email: str, request: Request):
+        lang = resolve_language(request)
         admin_email, users = require_admin(request)
         if email == admin_email:
-            raise HTTPException(status_code=400, detail="자기 자신은 삭제할 수 없습니다.")
+            raise http_error(400, "admin.cannot_delete_self", lang)
         if email not in users:
-            raise HTTPException(status_code=404, detail="사용자를 찾을 수 없습니다.")
+            raise http_error(404, "auth.user_not_found", lang)
         deleted = public_user(email, users[email], users)
         append_audit_event("user_delete", user_email=admin_email, target_email=email, deleted_user=deleted)
         del users[email]