ltcai 10.7.0 → 10.9.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.9.0 Living Brain walkthrough](output/release/v10.9.0/gifs/v10.9.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.9.0/screenshots/04-brain-chat-home.png) | **See how knowledge connects** — a real relationship graph, not a file list ![Memory Graph](output/release/v10.9.0/screenshots/05-memory-graph.png) |
+| **Capture anything** — files, whole folders, notes, screenshots, web pages ![Capture](output/release/v10.9.0/screenshots/06-capture.png) | **Automate with review** — agent changes become proposals you approve first ![Review Center](output/release/v10.9.0/screenshots/12-review-center.png) |
+| **Pick a model in one click** — recommended local models for your hardware ![Recommended Models](output/release/v10.9.0/screenshots/02-recommended-models.png) | **Stay in control** — audit, roles, retention in a separate admin surface ![Admin Console](output/release/v10.9.0/screenshots/10-admin-console.png) |
+| **Watch a file become memory** — three named steps, not a pipeline diagram ![Material to memory](output/release/v10.9.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.9.0/screenshots/08-system.png) |
 
 ## Why Lattice AI
 
@@ -58,51 +58,64 @@ 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.9.0/screenshots/01-login.png) | ![Model install](output/release/v10.9.0/screenshots/03-install-load-progress.png) | ![Model library](output/release/v10.9.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.9.0/SCREENSHOT_INDEX.md](output/release/v10.9.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.9.0 — Never Blocks**:
+
+Lattice AI runs one event loop on your computer. Several things you could ask
+it to do were being done *on* that loop, so while they ran the server could not
+answer anything else. Downloading a model has a fifteen-minute timeout; that is
+how long the whole product could be frozen by one click.
+
+- **Nothing long runs on the event loop.** Model pulls, engine installs, MCP
+  package installs and the CPU/RAM probe behind the System screen all moved to
+  a worker thread. `/local/sysinfo` is the one most people met without knowing:
+  it is read by the System screen *and* by first-run analysis, so its ~2s
+  freeze landed exactly while an answer was streaming. Two things keep it
+  fixed — ruff's `ASYNC` blocking-call rules, and
+  `tests/unit/test_event_loop_not_blocked.py`, which runs a ticker coroutine
+  during the handler and asserts the loop kept getting control.
+- **A focus ring you can see.** 10.8.0 added `border-color` to the transition
+  on the capture pills, so keyboard focus faded in over 150ms and at the
+  instant it landed the pill still looked idle. Focus rings may not ease.
+- **The Brain stops thinking when it has answered.** A retrieval pulse parked a
+  900ms timer that put the organism back into "thinking"; if the answer
+  finished inside that window the timer still fired, and the Brain sat visibly
+  working on a question it had already answered.
+- **One language, further in.** Fourteen more routers moved to the message
+  catalog — chat, memory, graph, files, portability, review, models, tools,
+  MCP, setup. `models.py`, `mcp.py` and `tools.py` had been answering some
+  errors in Korean and others in English on the same screen. Two gates keep
+  them migrated, and a third fails if the two gates disagree.
+- **The welcome screen fits.** It measured 770px against a 747px viewport, so
+  the line explaining what you are agreeing to sat under the fold. Nothing was
+  removed; the whitespace gave back the 25px.
+- **The streaming answer path has tests.** `useBrainChat` was 12% covered
+  because asserting anything about a stream needs frames arriving over time.
+  `frontend/src/test/fakeChatStream.ts` is that harness; eleven cases now cover
+  the answer building up, the stop button, refusals, grounding badges and live
+  step frames.
+- **Evidence bound to this build.** `output/release/v10.9.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/*`.
+  fingerprints that lint re-checks before merge. 10.9.0 claims no screen
+  redesign, and `scripts/release_screen_claims.json` says so explicitly.
+- **Exact artifact names only.** Publish paths list `dist/ltcai-10.9.0-*` and
+  `ltcai-10.9.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.9.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.9.0-py3-none-any.whl`
+- `dist/ltcai-10.9.0.tar.gz`
+- `ltcai-10.9.0.tgz`
+- `dist/ltcai-10.9.0.vsix`
+- `src-tauri/target/release/bundle/dmg/Lattice AI_10.9.0_aarch64.dmg`
 
 Do not use wildcard artifact uploads. Package registry publishing remains owner-run.
 
@@ -137,6 +150,8 @@ See [ARCHITECTURE.md](ARCHITECTURE.md) for details and
 
 | Version | Theme |
 | --- | --- |
+| 10.9.0 | Never Blocks |
+| 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,74 @@ 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.9.0] - 2026-08-05
+
+### Fixed
+- 모델 내려받기(`ollama pull`, Hugging Face), 엔진 설치, MCP `pip`/`npm` 설치,
+  `/local/sysinfo` 호스트 측정이 `async def` 안에서 그대로 실행되어 실행 중
+  서버 전체가 다른 요청을 처리하지 못하던 문제 — 전부 `asyncio.to_thread`로
+  이관. 최악의 경우 15분(다운로드 타임아웃)간 채팅·`/health`·UI가 모두 멈췄습니다.
+- Telegram 브리지의 사진/문서 업로드가 파일을 이벤트 루프에서 읽던 문제.
+- 캡처 필의 키보드 포커스 테두리가 150ms에 걸쳐 서서히 나타나, 포커스가 닿는
+  순간에는 여전히 idle 색이던 문제(`home-simple.css` transition에서
+  `border-color` 제거).
+- 답변이 끝난 뒤에도 Brain 유기체가 "생각 중"에 머물던 문제 — 회상 펄스가
+  건 900ms 타이머가 스트림 종료 시 취소되지 않았습니다.
+- 같은 틱에 두 번 전송될 때 `stopStreaming`이 중단 핸들을 잃던 문제.
+- 환영 화면이 747px 뷰포트에서 770px이라 마지막 안내 문장이 접힌 부분 아래에
+  있던 문제(`@media (max-height: 820px)` 단계 추가).
+
+### Added
+- `tests/unit/test_event_loop_not_blocked.py` — 핸들러 실행 중 티커 코루틴을
+  돌려 이벤트 루프가 실제로 제어권을 받았는지 측정하는 회귀 테스트.
+- `frontend/src/test/fakeChatStream.ts` — 프레임이 시간에 걸쳐 도착하는 가짜
+  SSE 하네스. `useBrainChat.test.tsx` 11개 시나리오.
+- `scripts/check_server_i18n.mjs` — 이관 완료 선언된 라우터에서 문자열 리터럴
+  detail을 금지하는 lint 게이트(`npm run lint`에 편입).
+- `tests/visual/v3.spec.js` — 환영 화면 fold 테스트, 캡처 필 포커스 테두리.
+- ruff `ASYNC210/220/221/222/230/251` 규칙.
+
+### Changed
+- 서버 메시지 카탈로그를 14개 라우터로 확대(chat, chat_history, chat_intents,
+  memory, knowledge_graph, local_files, portability, review_queue,
+  project_sessions, network_boundary, models, tools, mcp, setup) — 총 17개.
+  `MIGRATED_ROUTERS`와 lint 게이트 목록이 어긋나면 테스트가 실패합니다.
+- `latticeai/services/model_loading.py`: 엔진 준비/다운로드 블록을
+  `_prepare_model_sources()`로 추출(워커 스레드에서 실행 가능한 동기 함수).
+- `latticeai/api/static_routes.py`: 호스트 측정을 `_probe_host_capacity()`로
+  추출.
+
+## [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.9.0 — Never Blocks**.
 
 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.9.0 — Never Blocks**.
 
 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.9.0 — Never Blocks**.
 
 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.9.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.9.0 — Never Blocks**.
 
 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.9.0 — Never Blocks**.
 
 **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.9.0 — Never Blocks**.
 
 명세 출처: `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.9.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.9.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.9.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]