ltcai 10.7.0 → 10.8.0

package/README.md

@@ -11,7 +11,7 @@
 [![CI Status](https://github.com/TaeSooPark-PTS/LatticeAI/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/TaeSooPark-PTS/LatticeAI/actions/workflows/ci.yml)
 [![License](https://img.shields.io/badge/license-MIT-green)](LICENSE)
 
-![v10.7.0 Living Brain walkthrough](output/release/v10.7.0/gifs/v10.7.0-living-brain-walkthrough.gif)
+![v10.8.0 Living Brain walkthrough](output/release/v10.8.0/gifs/v10.8.0-living-brain-walkthrough.gif)
 
 Chat, files, folders, notes, and web pages all flow into one durable knowledge
 graph on your computer. Any model — local MLX or cloud — can speak with that
@@ -24,10 +24,10 @@ memory. Nothing leaves your machine without explicit consent.
 
 | | |
 | --- | --- |
-| **Chat with a Brain that remembers** — every conversation grows durable, source-linked memory ![Brain Chat](output/release/v10.7.0/screenshots/04-brain-chat-home.png) | **See how knowledge connects** — a real relationship graph, not a file list ![Memory Graph](output/release/v10.7.0/screenshots/05-memory-graph.png) |
-| **Capture anything** — files, whole folders, notes, screenshots, web pages ![Capture](output/release/v10.7.0/screenshots/06-capture.png) | **Automate with review** — agent changes become proposals you approve first ![Review Center](output/release/v10.7.0/screenshots/12-review-center.png) |
-| **Pick a model in one click** — recommended local models for your hardware ![Recommended Models](output/release/v10.7.0/screenshots/02-recommended-models.png) | **Stay in control** — audit, roles, retention in a separate admin surface ![Admin Console](output/release/v10.7.0/screenshots/10-admin-console.png) |
-| **Watch a file become memory** — three named steps, not a pipeline diagram ![Material to memory](output/release/v10.7.0/screenshots/11-knowledge-journey.png) | **Say how much it may do alone** — one dial in plain words; dangerous actions stay blocked either way ![Settings](output/release/v10.7.0/screenshots/08-system.png) |
+| **Chat with a Brain that remembers** — every conversation grows durable, source-linked memory ![Brain Chat](output/release/v10.8.0/screenshots/04-brain-chat-home.png) | **See how knowledge connects** — a real relationship graph, not a file list ![Memory Graph](output/release/v10.8.0/screenshots/05-memory-graph.png) |
+| **Capture anything** — files, whole folders, notes, screenshots, web pages ![Capture](output/release/v10.8.0/screenshots/06-capture.png) | **Automate with review** — agent changes become proposals you approve first ![Review Center](output/release/v10.8.0/screenshots/12-review-center.png) |
+| **Pick a model in one click** — recommended local models for your hardware ![Recommended Models](output/release/v10.8.0/screenshots/02-recommended-models.png) | **Stay in control** — audit, roles, retention in a separate admin surface ![Admin Console](output/release/v10.8.0/screenshots/10-admin-console.png) |
+| **Watch a file become memory** — three named steps, not a pipeline diagram ![Material to memory](output/release/v10.8.0/screenshots/11-knowledge-journey.png) | **Say how much it may do alone** — one dial in plain words; dangerous actions stay blocked either way ![Settings](output/release/v10.8.0/screenshots/08-system.png) |
 
 ## Why Lattice AI
 
@@ -58,51 +58,63 @@ First-run flow — wake the Brain, pick the owner, load a recommended model:
 
 | | | |
 | --- | --- | --- |
-| ![Login](output/release/v10.7.0/screenshots/01-login.png) | ![Model install](output/release/v10.7.0/screenshots/03-install-load-progress.png) | ![Model library](output/release/v10.7.0/screenshots/07-model-library.png) |
+| ![Login](output/release/v10.8.0/screenshots/01-login.png) | ![Model install](output/release/v10.8.0/screenshots/03-install-load-progress.png) | ![Model library](output/release/v10.8.0/screenshots/07-model-library.png) |
 
 Screenshot index and capture notes:
-[output/release/v10.7.0/SCREENSHOT_INDEX.md](output/release/v10.7.0/SCREENSHOT_INDEX.md)
+[output/release/v10.8.0/SCREENSHOT_INDEX.md](output/release/v10.8.0/SCREENSHOT_INDEX.md)
 
 ## Current Release
 
-The current release is **10.7.0 — Plain Surface**:
-
-Every screen was rebuilt. Lattice AI is a personal memory system that runs on
-your own machine, and it had come to look like an operations console — dense
-grids of panels, developer vocabulary in the labels, and the thing you came to
-do buried under the things you rarely touch. 10.7.0 rearranges all twelve
-screens around what the person is actually there for, in plain language.
-
-**Nothing was removed to achieve it.** The 38 hash destinations in
-`frontend/src/routes.ts` are the same 38 as before the rebuild — none dropped,
-none added. `frontend/src/routes.test.ts` checks every one of them resolves to a
-real screen, and names the landing spot outright for the paths most likely to
-regress.
-
-- **Layout actually changed.** `scripts/check_screenshot_pixel_delta.py` compares
-  all twelve captures against the previous release and fails when a screen only
-  changed its wording. Multi-column grid classes across `frontend/src` fell from
-  22 occurrences to 6, 4 of them outside test assertions —
-  `grep -rhoE 'grid-cols-[a-z0-9]+' frontend/src | wc -l` against the
-  pre-rebuild tree and this one.
-- **Features still reachable.** Every destination was rearranged, not retired:
-  38 → 38. Copy keys have no such gate — 18 keys no screen rendered any more
-  were removed by hand, each after checking the feature is reachable elsewhere.
-- **Evidence bound to this build.** `output/release/v10.7.0/` holds the twelve
+The current release is **10.8.0 — Within Reach**:
+
+10.7.0 rearranged all twelve screens. 10.8.0 is about the things that were
+already there but out of reach: a button below the fold, a message in a
+language you did not choose, a file a small model nearly produced.
+
+- **The first three screens fit on the screen.** Onboarding rendered a 390px
+  decorative Brain above *every* step, so on a 1440×900 display the login
+  form, the recommended model and the install progress all began below the
+  fold — the first thing the product asked a new person to do was scroll. The
+  organism is a hero on the welcome step and a 104px mark after it; the
+  welcome screen itself went from 1175px of content to 770px, so its primary
+  button is visible without scrolling.
+- **One language per screen, including the ones the server writes.** API
+  messages were literals at the raise site, written in whichever language the
+  endpoint's author was thinking in — Korean from `auth.py`, English from
+  `browser.py`. `latticeai/core/messages.py` is a catalog with both, resolved
+  from `X-Lattice-Language` (falling back to `Accept-Language`); the browser
+  extension, which showed English and Korean in the same popup, has one too.
+  `tests/unit/test_server_messages.py` fails on a message that exists in only
+  one language, and on a router that reverts to a hardcoded literal.
+- **A small model's near-miss is no longer thrown away.** File generation
+  picked the *longest* rejected reply to repair, so a 900-character apology
+  beat a truncated-but-real HTML document; it now scores candidates by how
+  close they are to being a file. A byte-identical repeated reply buys one
+  extra attempt with a prompt that names the repetition. Prose file types
+  (`.md`, `.txt`) had no validation at all and would save "Sure! Here is the
+  document:" as the document.
+- **Re-indexing costs what changed.** The incremental vector rebuild
+  materialised every node and chunk in memory and asked one `SELECT` per item
+  whether it had changed. It streams now, with a single prefetched hash map —
+  and a settled index performs zero embeddings, asserted rather than assumed.
+- **More ground under the frontend.** Statement coverage 47.35% → 52.26%,
+  424 → 504 tests, including the app shell (`App.tsx`, previously 0%), the
+  admin console (0%), the folder picker (2.7%) and the API client.
+- **Evidence bound to this build.** `output/release/v10.8.0/` holds the twelve
   capture screens, walkthrough gif/webm, and the asset-manifest / mock-server
   fingerprints that lint re-checks before merge.
-- **Exact artifact names only.** Publish paths list `dist/ltcai-10.7.0-*` and
-  `ltcai-10.7.0.tgz` — never `dist/*`.
+- **Exact artifact names only.** Publish paths list `dist/ltcai-10.8.0-*` and
+  `ltcai-10.8.0.tgz` — never `dist/*`.
 
 Release notes: [RELEASE.md](RELEASE.md) · Full history: [docs/CHANGELOG.md](docs/CHANGELOG.md)
 
-Expected artifacts for 10.7.0 release must use exact filenames:
+Expected artifacts for 10.8.0 release must use exact filenames:
 
-- `dist/ltcai-10.7.0-py3-none-any.whl`
-- `dist/ltcai-10.7.0.tar.gz`
-- `ltcai-10.7.0.tgz`
-- `dist/ltcai-10.7.0.vsix`
-- `src-tauri/target/release/bundle/dmg/Lattice AI_10.7.0_aarch64.dmg`
+- `dist/ltcai-10.8.0-py3-none-any.whl`
+- `dist/ltcai-10.8.0.tar.gz`
+- `ltcai-10.8.0.tgz`
+- `dist/ltcai-10.8.0.vsix`
+- `src-tauri/target/release/bundle/dmg/Lattice AI_10.8.0_aarch64.dmg`
 
 Do not use wildcard artifact uploads. Package registry publishing remains owner-run.
 
@@ -137,6 +149,7 @@ See [ARCHITECTURE.md](ARCHITECTURE.md) for details and
 
 | Version | Theme |
 | --- | --- |
+| 10.8.0 | Within Reach |
 | 10.7.0 | Plain Surface |
 | 10.6.4 | Loud Limits |
 | 10.6.3 | Loud Limits |

package/docs/CHANGELOG.md

@@ -4,6 +4,37 @@ The top entry is either the current unreleased main-branch work or the current
 release line. Older entries are historical and may describe behavior as it
 existed at that release.
 
+## [10.8.0] - 2026-08-04
+
+### Fixed
+- 온보딩 login/recommend/install 3개 화면에서 주 작업이 접힌 부분 아래에서
+  시작하던 문제 — 히어로 브레인을 단계별 크기(`data-scale`)로 분리.
+- 설치 화면이 번역 키 원문(`flow.install.stage.idle`)을 사용자에게 출력하던
+  문제 — `t()`가 `defaultValue` 옵션을 읽지 않았고, 옵션 자체가 보간 값으로
+  새어 들어가고 있었습니다.
+- 추천 모델 화면이 셸 중앙에서 왼쪽으로 치우쳐 있던 문제(`margin-inline`).
+- Brain 대화 홈의 추천 칩이 4글자를 담은 채 952px로 늘어나던 문제 —
+  `@media (max-height)` 블록이 `display:flex`만 재선언하고 `flex-direction`을
+  다시 쓰지 않아 기본 규칙의 `column` 축을 물려받고 있었습니다.
+- 브라우저 확장 팝업이 한 창 안에서 한국어와 영어를 섞어 보여주던 문제.
+
+### Added
+- `latticeai/core/messages.py` — 서버 사이드 메시지 카탈로그(ko/en)와
+  요청 기반 언어 결정(`X-Lattice-Language` → `Accept-Language`).
+- `frontend/src/styles/mediaQueryOverride.test.ts` — 미디어 쿼리가 `display`를
+  재선언하면서 축을 다시 쓰지 않는 부분 오버라이드 가드.
+- 신규 테스트 스위트: `App.tsx`, `AdminConsole.tsx`, `lib/folderPicker.ts`,
+  `api/client.ts` 확장, 멀티에이전트 JSON 복구, 증분 인덱스 재빌드.
+
+### Changed
+- 파일 생성이 실패 응답 중 "가장 긴" 것이 아니라 "가장 파일에 가까운" 것을
+  복구에 넘깁니다. 동일 응답 반복 시 1회 한정 추가 시도.
+- 산문 파일 타입(`.md`/`.txt`/…)에도 검증 추가 — 파일에 *대한* 답변은 파일이
+  아닙니다.
+- 멀티에이전트 계획 파서: 균형 스팬 스캔 + `<think>` 제거 + trailing comma 복구.
+- 증분 벡터 재빌드가 스트리밍 + 단일 해시맵 조회로 전환.
+- `latticeai/core/workspace_os.py` 1128 → 945줄.
+
 ## [10.7.0] - 2026-08-04
 
 ### Changed

package/docs/COMMUNITY_AND_PLUGINS.md

@@ -1,6 +1,6 @@
 # Community And Plugins
 
-Current release: **10.7.0 — Plain Surface**.
+Current release: **10.8.0 — Within Reach**.
 
 LatticeAI defines the path from a strong local-first framework (8.4.0
 action-aware baseline, 8.5.0 registry+DI hardening, 8.6.0 capture/navigation

package/docs/DEVELOPMENT.md

@@ -3,7 +3,7 @@
 > **Status: canonical** — current contributor guidance, kept in sync with the
 > current release.
 
-Current release: **10.7.0 — Plain Surface**.
+Current release: **10.8.0 — Within Reach**.
 
 This document is for contributors working on the local-first Digital Brain
 codebase. Product positioning and quick start stay in `README.md`; release

package/docs/ONBOARDING.md

@@ -1,6 +1,6 @@
 # Lattice AI Onboarding
 
-Current release: **10.7.0 — Plain Surface**.
+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.7.0)
+# 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

package/docs/TRUST_MODEL.md

@@ -1,6 +1,6 @@
 # Lattice AI Trust Model
 
-Current release: **10.7.0 — Plain Surface**.
+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.7.0 — Plain Surface**.
+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.7.0 — Plain Surface**.
+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.7.0"
+__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.7.0"
+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.7.0"
+__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
 
 
@@ -391,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)
@@ -410,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]