ltcai 8.9.0 → 9.1.0

package/local_knowledge_api.py

@@ -1,345 +1,7 @@
-"""Local folder knowledge-source API and optional filesystem watcher."""
+"""Compatibility shim for :mod:`latticeai.services.local_knowledge`."""
 
-import logging
-import threading
-from pathlib import Path
-from typing import Any, Callable, Dict, Optional
+import sys
 
-from fastapi import APIRouter, HTTPException, Request
-from pydantic import BaseModel, Field
+from latticeai.services import local_knowledge as _impl
 
-
-class LocalTreeRequest(BaseModel):
-    path: str
-    max_items: int = 200
-    approved: bool = False
-    approval_token: Optional[str] = None
-
-
-class LocalKnowledgeAuditRequest(BaseModel):
-    path: str
-    include_ocr: bool = False
-    max_files: int = 50_000
-    approved: bool = False
-    approval_token: Optional[str] = None
-
-
-class LocalKnowledgeIndexRequest(BaseModel):
-    path: str
-    include_ocr: bool = False
-    watch_enabled: bool = False
-    max_files: int = 5_000
-    consent: Dict[str, Any] = Field(default_factory=dict)
-    approved: bool = False
-    approval_token: Optional[str] = None
-
-
-class LocalKnowledgeWatchRequest(BaseModel):
-    source_id: str
-
-
-class _LocalWatchHandler:
-    def __init__(self, schedule_change: Callable[[], None]):
-        self._schedule_change = schedule_change
-
-    def on_any_event(self, event):  # pragma: no cover - exercised by OS watcher
-        if getattr(event, "is_directory", False):
-            return
-        self._schedule_change()
-
-
-class LocalKnowledgeWatcher:
-    """Debounced watchdog wrapper for approved local knowledge sources."""
-
-    def __init__(self, get_graph: Callable[[], Any], *, debounce_seconds: float = 5.0, hooks: Any = None):
-        self._get_graph = get_graph
-        self._debounce_seconds = debounce_seconds
-        self._hooks = hooks
-        self._lock = threading.Lock()
-        self._watched: Dict[str, Dict[str, Any]] = {}
-        self._observer_cls = None
-        self._event_handler_base = None
-        self._import_error = ""
-        try:
-            from watchdog.events import FileSystemEventHandler
-            from watchdog.observers import Observer
-
-            self._observer_cls = Observer
-            self._event_handler_base = FileSystemEventHandler
-        except Exception as exc:  # pragma: no cover - depends on optional dependency
-            self._import_error = str(exc)
-
-    @property
-    def available(self) -> bool:
-        return self._observer_cls is not None and self._event_handler_base is not None
-
-    def status(self) -> Dict[str, Any]:
-        with self._lock:
-            active = {
-                source_id: {
-                    "root_path": item["source"].get("root_path"),
-                    "last_event_at": item.get("last_event_at"),
-                    "last_indexed_at": item.get("last_indexed_at"),
-                    "last_error": item.get("last_error"),
-                }
-                for source_id, item in self._watched.items()
-            }
-        return {
-            "available": self.available,
-            "error": "" if self.available else self._import_error or "watchdog is not installed",
-            "debounce_seconds": self._debounce_seconds,
-            "active": active,
-        }
-
-    def restore_enabled_sources(self) -> Dict[str, Any]:
-        graph = self._get_graph()
-        if graph is None:
-            return {"restored": 0, "available": self.available}
-        restored = 0
-        try:
-            for source in graph.local_sources().get("sources", []):
-                if source.get("watch_enabled"):
-                    result = self.start_source(source)
-                    if result.get("watching"):
-                        restored += 1
-        except Exception as exc:
-            logging.warning("local knowledge watcher restore failed: %s", exc)
-        return {"restored": restored, "available": self.available}
-
-    def start_source(self, source: Dict[str, Any]) -> Dict[str, Any]:
-        source_id = str(source.get("id") or "")
-        root_path = str(source.get("root_path") or "")
-        if not source_id or not root_path:
-            return {"watching": False, "error": "source_id and root_path are required"}
-        if not self.available:
-            return {"watching": False, "source_id": source_id, "error": self._import_error or "watchdog is not installed"}
-        root = Path(root_path).expanduser().resolve()
-        if not root.exists() or not root.is_dir():
-            return {"watching": False, "source_id": source_id, "error": "source folder is not available"}
-
-        self.stop_source(source_id)
-
-        class Handler(_LocalWatchHandler, self._event_handler_base):  # type: ignore[misc, valid-type]
-            def __init__(handler_self):
-                self._event_handler_base.__init__(handler_self)
-                _LocalWatchHandler.__init__(handler_self, lambda: self._schedule(source_id))
-
-        observer = self._observer_cls()
-        try:
-            observer.schedule(Handler(), str(root), recursive=True)
-            observer.start()
-        except Exception as exc:
-            logging.warning("local knowledge watcher start failed for %s: %s", root, exc)
-            return {"watching": False, "source_id": source_id, "error": str(exc)}
-
-        with self._lock:
-            self._watched[source_id] = {
-                "observer": observer,
-                "timer": None,
-                "source": dict(source),
-                "last_event_at": None,
-                "last_indexed_at": None,
-                "last_error": None,
-            }
-        return {"watching": True, "source_id": source_id, "root_path": str(root)}
-
-    def stop_source(self, source_id: str) -> Dict[str, Any]:
-        with self._lock:
-            item = self._watched.pop(source_id, None)
-        if not item:
-            return {"stopped": False, "source_id": source_id}
-        timer = item.get("timer")
-        if timer:
-            timer.cancel()
-        observer = item.get("observer")
-        try:
-            observer.stop()
-            observer.join(timeout=3)
-        except Exception as exc:
-            logging.warning("local knowledge watcher stop failed for %s: %s", source_id, exc)
-        return {"stopped": True, "source_id": source_id}
-
-    def stop_all(self) -> None:
-        for source_id in list(self.status().get("active", {}).keys()):
-            self.stop_source(source_id)
-
-    def _schedule(self, source_id: str) -> None:
-        with self._lock:
-            item = self._watched.get(source_id)
-            if not item:
-                return
-            timer = item.get("timer")
-            if timer:
-                timer.cancel()
-            item["last_event_at"] = _now_seconds()
-            timer = threading.Timer(self._debounce_seconds, self._run_index, args=(source_id,))
-            timer.daemon = True
-            item["timer"] = timer
-            timer.start()
-
-    def _run_index(self, source_id: str) -> None:
-        with self._lock:
-            item = self._watched.get(source_id)
-            if not item:
-                return
-            source = dict(item["source"])
-            item["timer"] = None
-        graph = self._get_graph()
-        if graph is None:
-            return
-        consent = source.get("consent") or {}
-        root = source.get("root_path")
-        if self._hooks is not None:
-            self._hooks.fire_hook("pre_index", "folder.reindex",
-                                  payload={"source_id": source_id, "root_path": root, "trigger": "watch"})
-        try:
-            graph.index_local_folder(
-                Path(source["root_path"]),
-                include_ocr=bool(source.get("include_ocr")),
-                watch_enabled=True,
-                user_email=consent.get("approved_by"),
-                consent=consent,
-            )
-            with self._lock:
-                if source_id in self._watched:
-                    self._watched[source_id]["last_indexed_at"] = _now_seconds()
-                    self._watched[source_id]["last_error"] = None
-            if self._hooks is not None:
-                self._hooks.fire_hook("post_index", "folder.reindex",
-                                      payload={"source_id": source_id, "root_path": root, "trigger": "watch", "status": "ok"})
-        except Exception as exc:
-            logging.warning("local knowledge watcher reindex failed for %s: %s", source_id, exc)
-            with self._lock:
-                if source_id in self._watched:
-                    self._watched[source_id]["last_error"] = str(exc)
-            if self._hooks is not None:
-                self._hooks.fire_hook("post_index", "folder.reindex",
-                                      payload={"source_id": source_id, "root_path": root, "trigger": "watch", "status": "error", "error": str(exc)})
-
-
-def _now_seconds() -> float:
-    import time
-
-    return time.time()
-
-
-def create_local_knowledge_router(
-    *,
-    get_graph: Callable[[], Any],
-    require_graph: Callable[[], None],
-    require_user: Callable[[Request], str],
-    require_local_user: Callable[[Request], str],
-    local_permission_response: Callable[..., dict],
-    require_local_approval: Callable[..., None],
-    watcher: Optional[LocalKnowledgeWatcher] = None,
-    hooks: Any = None,
-) -> APIRouter:
-    router = APIRouter()
-
-    def graph():
-        require_graph()
-        return get_graph()
-
-    @router.get("/knowledge-graph/local/roots")
-    async def knowledge_graph_local_roots(request: Request):
-        require_user(request)
-        return graph().discover_local_roots()
-
-    @router.get("/knowledge-graph/local/sources")
-    async def knowledge_graph_local_sources(request: Request):
-        require_user(request)
-        payload = graph().local_sources()
-        watch_status = watcher.status() if watcher else {"available": False, "active": {}}
-        active = watch_status.get("active", {})
-        for source in payload.get("sources", []):
-            source["watch_active"] = source.get("id") in active
-            source["watch_status"] = active.get(source.get("id"))
-        payload["watch"] = watch_status
-        return payload
-
-    @router.get("/knowledge-graph/local/watch/status")
-    async def knowledge_graph_local_watch_status(request: Request):
-        require_user(request)
-        graph()
-        return watcher.status() if watcher else {"available": False, "active": {}, "error": "watcher unavailable"}
-
-    @router.post("/knowledge-graph/local/watch/stop")
-    async def knowledge_graph_local_watch_stop(req: LocalKnowledgeWatchRequest, request: Request):
-        require_user(request)
-        kg = graph()
-        try:
-            kg.set_local_source_watch(req.source_id, False)
-        except ValueError as exc:
-            raise HTTPException(status_code=404, detail=str(exc)) from exc
-        result = watcher.stop_source(req.source_id) if watcher else {"stopped": False, "source_id": req.source_id}
-        return {"status": "ok", "watch": result}
-
-    @router.post("/knowledge-graph/local/tree")
-    async def knowledge_graph_local_tree(req: LocalTreeRequest, request: Request):
-        current_user = require_local_user(request)
-        kg = graph()
-        if not req.approved:
-            return local_permission_response(req.path, "list", current_user)
-        require_local_approval(token=req.approval_token, path=req.path, action="list", user_email=current_user)
-        try:
-            return kg.preview_local_tree(Path(req.path), max_items=req.max_items)
-        except ValueError as exc:
-            raise HTTPException(status_code=400, detail=str(exc)) from exc
-
-    @router.post("/knowledge-graph/local/audit")
-    async def knowledge_graph_local_audit(req: LocalKnowledgeAuditRequest, request: Request):
-        current_user = require_local_user(request)
-        kg = graph()
-        if not req.approved:
-            return local_permission_response(req.path, "list", current_user)
-        require_local_approval(token=req.approval_token, path=req.path, action="list", user_email=current_user)
-        try:
-            return kg.audit_local_folder(Path(req.path), include_ocr=req.include_ocr, max_files=req.max_files)
-        except ValueError as exc:
-            raise HTTPException(status_code=400, detail=str(exc)) from exc
-
-    @router.post("/knowledge-graph/local/index")
-    async def knowledge_graph_local_index(req: LocalKnowledgeIndexRequest, request: Request):
-        current_user = require_local_user(request)
-        kg = graph()
-        if not req.approved:
-            return local_permission_response(req.path, "read", current_user)
-        require_local_approval(token=req.approval_token, path=req.path, action="read", user_email=current_user)
-        if hooks is not None:
-            hooks.fire_hook("pre_index", "folder.index",
-                            payload={"root_path": req.path, "trigger": "connect", "watch": req.watch_enabled},
-                            user_email=current_user)
-        try:
-            result = kg.index_local_folder(
-                Path(req.path),
-                include_ocr=req.include_ocr,
-                watch_enabled=req.watch_enabled,
-                user_email=current_user,
-                consent=req.consent or {},
-                max_files=req.max_files,
-            )
-        except ValueError as exc:
-            if hooks is not None:
-                hooks.fire_hook("post_index", "folder.index",
-                                payload={"root_path": req.path, "trigger": "connect", "status": "error", "error": str(exc)},
-                                user_email=current_user)
-            raise HTTPException(status_code=400, detail=str(exc)) from exc
-        if hooks is not None:
-            _idx = (result.get("index") or {}) if isinstance(result, dict) else {}
-            hooks.fire_hook("post_index", "folder.index",
-                            payload={"root_path": req.path, "trigger": "connect", "status": "ok",
-                                     "indexed": _idx.get("indexed") or (result or {}).get("indexed")},
-                            user_email=current_user)
-
-        if watcher:
-            if req.watch_enabled:
-                source_payload = {
-                    **result.get("source", {}),
-                    "consent": {"approved_by": current_user, **(req.consent or {})},
-                }
-                result["watch"] = watcher.start_source(source_payload)
-            else:
-                result["watch"] = watcher.stop_source(result.get("source", {}).get("id", ""))
-        return result
-
-    return router
+sys.modules[__name__] = _impl

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ltcai",
-  "version": "8.9.0",
+  "version": "9.1.0",
   "description": "Lattice AI — local-first Digital Brain that keeps your knowledge durable across any AI model.",
   "homepage": "https://github.com/TaeSooPark-PTS/LatticeAI#readme",
   "repository": {
@@ -20,18 +20,23 @@
     "build": "npm run build:assets && npm run build:python",
     "frontend:dev": "vite --host 127.0.0.1",
     "frontend:openapi": "node scripts/run_python.mjs scripts/export_openapi.py frontend/openapi.json && npx openapi-typescript frontend/openapi.json -o frontend/src/api/openapi.ts",
+    "frontend:openapi:check": "node scripts/check_openapi_drift.mjs",
     "build:assets": "vite build && node scripts/build_frontend_assets.mjs",
     "build:python": "node scripts/run_python.mjs -m build",
     "check:python": "node scripts/run_python.mjs scripts/check_python.py",
-    "lint": "npm run lint:python && node --check tests/visual/mock_server.cjs && node --check tests/visual/v3.spec.js && npm run lint:frontend && node scripts/check_i18n_literals.mjs",
+    "lint": "npm run lint:python && node --check tests/visual/mock_server.cjs && node --check tests/visual/v3.spec.js && npm run lint:frontend && npm run frontend:openapi:check && node scripts/check_i18n_literals.mjs && npm run test:browser-extension",
     "lint:python": "node scripts/run_python.mjs -m ruff check .",
     "lint:frontend": "node scripts/lint_frontend.mjs",
     "docs:check-links": "node scripts/check_markdown_links.mjs",
+    "docs:check-current": "node scripts/check_current_release_docs.mjs",
     "typecheck": "npm run typecheck:frontend && cd vscode-extension && npm run build",
     "typecheck:frontend": "npx tsc -p tsconfig.json --noEmit",
     "test": "node scripts/run_python.mjs -m pytest tests/ -v",
+    "test:frontend": "vitest run",
+    "test:frontend:watch": "vitest",
     "test:unit": "node scripts/run_python.mjs -m pytest tests/unit/ -v",
     "test:integration": "node scripts/run_integration_tests.mjs",
+    "test:browser-extension": "node --check browser-extension/popup.js && node --check browser-extension/capture-page.js && node --test tests/browser-extension.test.cjs",
     "test:visual": "playwright test",
     "vercel:build": "node scripts/build_vercel_static.mjs",
     "desktop:tauri": "tauri dev",
@@ -39,6 +44,7 @@
     "desktop:tauri:check": "cd src-tauri && cargo check",
     "desktop:electron": "electron desktop/electron/main.cjs",
     "package:vsix": "node scripts/build_vsix.mjs",
+    "release:evidence": "node scripts/capture_release_evidence.mjs",
     "release:artifacts": "node scripts/clean_release_artifacts.mjs $npm_package_version && npm run build:assets && npm run build:python && npm pack && npm run package:vsix && npm run desktop:tauri:build",
     "release:validate": "node scripts/run_python.mjs scripts/validate_release_artifacts.py $npm_package_version --require-vsix --require-tgz --require-dmg",
     "release:smoke": "node scripts/run_python.mjs scripts/release_smoke.py $npm_package_version",
@@ -90,7 +96,16 @@
     "static/icons/",
     "plugins/",
     "scripts/",
+    "!bin/pts-grok",
     "!scripts/launch-pts-grok.sh",
+    "!scripts/*discord-bridge*.mjs",
+    "!scripts/start-*-discord.sh",
+    "!scripts/com.*.discord.plist",
+    "!HEARTBEAT.md",
+    "!IDENTITY.md",
+    "!SOUL.md",
+    "!TOOLS.md",
+    "!USER.md",
     "!docs/images/tmp_frames/",
     "!**/__pycache__/",
     "!**/*.pyc",
@@ -118,6 +133,9 @@
     "@tanstack/react-query": "^5.101.0",
     "@tauri-apps/api": "^2.11.1",
     "@tauri-apps/cli": "^2.11.3",
+    "@testing-library/jest-dom": "^6.9.1",
+    "@testing-library/react": "^16.3.2",
+    "@testing-library/user-event": "^14.6.1",
     "@types/cytoscape": "^3.21.9",
     "@types/react": "^19.2.17",
     "@types/react-dom": "^19.2.3",
@@ -127,6 +145,7 @@
     "clsx": "^2.1.1",
     "cytoscape": "^3.34.0",
     "electron": "^42.4.0",
+    "jsdom": "^29.1.1",
     "lucide-react": "^1.17.0",
     "openapi-fetch": "^0.17.0",
     "openapi-typescript": "^7.13.0",
@@ -138,6 +157,7 @@
     "tailwindcss": "^4.3.0",
     "typescript": "^5.9.3",
     "vite": "^8.0.16",
+    "vitest": "^4.1.10",
     "zustand": "^5.0.14"
   },
   "overrides": {

package/scripts/brain_quality_eval.py

@@ -68,7 +68,9 @@ class _EvalGraph:
     def index_status(self):
         return {"vector_counts": {"node": 3, "chunk": 2}}
 
-    def search(self, q, limit=20):
+    def search(self, q, limit=20, *, allowed_workspaces=None):
+        if allowed_workspaces is not None and "personal" not in allowed_workspaces:
+            return {"matches": []}
         return {
             "matches": [
                 {

package/scripts/bump_version.py

@@ -29,12 +29,15 @@ TARGETS = [
     ("lattice_brain/runtime/multi_agent.py", "regex", r'(MULTI_AGENT_VERSION = ")([^"]+)(")'),
     ("latticeai/services/architecture_readiness.py", "regex", r'(ARCHITECTURE_VERSION_TARGET = ")([^"]+)(")'),
     ("latticeai/services/product_readiness.py", "regex", r'(PRODUCT_VERSION_TARGET = ")([^"]+)(")'),
+    ("latticeai/core/legacy_compatibility.py", "regex", r'(LEGACY_COMPATIBILITY_VERSION = ")([^"]+)(")'),
     ("pyproject.toml", "regex", r'(^version = ")([^"]+)(")'),
     ("package.json", "json", "version"),
     ("package-lock.json", "package-lock", None),
     ("vscode-extension/package.json", "json", "version"),
     ("vscode-extension/package-lock.json", "package-lock", None),
+    ("browser-extension/manifest.json", "json", "version"),
     ("src-tauri/Cargo.toml", "regex", r'(^version = ")([^"]+)(")'),
+    ("src-tauri/Cargo.lock", "regex", r'(name = "lattice-ai-desktop"\nversion = ")([^"]+)(")'),
     ("src-tauri/tauri.conf.json", "json", "version"),
     ("static/app/asset-manifest.json", "json", "version"),
 ]

package/scripts/capture_release_evidence.mjs

@@ -0,0 +1,180 @@
+import { chromium } from "playwright";
+import { execFileSync, spawn } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+
+const repoRoot = process.cwd();
+const version = JSON.parse(fs.readFileSync(path.join(repoRoot, "package.json"), "utf8")).version;
+const port = Number(process.env.LTCAI_RELEASE_EVIDENCE_PORT || 4936);
+const baseURL = `http://127.0.0.1:${port}`;
+const root = path.join(repoRoot, "output", "release", `v${version}`);
+const screenshots = path.join(root, "screenshots");
+const videos = path.join(root, "videos");
+const gifs = path.join(root, "gifs");
+
+// A release capture must be reproducible and must never retain partial videos
+// from an interrupted prior run.
+fs.rmSync(root, { recursive: true, force: true });
+fs.mkdirSync(screenshots, { recursive: true });
+fs.mkdirSync(videos, { recursive: true });
+fs.mkdirSync(gifs, { recursive: true });
+
+const server = spawn(process.execPath, ["tests/visual/mock_server.cjs"], {
+  cwd: repoRoot,
+  env: { ...process.env, LTCAI_VISUAL_PORT: String(port) },
+  stdio: ["ignore", "pipe", "pipe"],
+});
+
+async function waitForServer() {
+  const deadline = Date.now() + 15000;
+  while (Date.now() < deadline) {
+    try {
+      const res = await fetch(`${baseURL}/health`);
+      if (res.ok) return;
+    } catch {}
+    await new Promise((resolve) => setTimeout(resolve, 150));
+  }
+  throw new Error(`visual server did not start on ${baseURL}`);
+}
+
+async function shot(page, name) {
+  await page.waitForTimeout(120);
+  await page.screenshot({ path: path.join(screenshots, name), fullPage: true });
+}
+
+async function main() {
+  await waitForServer();
+
+  const browser = await chromium.launch({ headless: true });
+  const context = await browser.newContext({
+    viewport: { width: 1440, height: 920 },
+    recordVideo: { dir: videos, size: { width: 1280, height: 818 } },
+  });
+  const page = await context.newPage();
+  page.setDefaultTimeout(15000);
+
+  await page.addInitScript(() => {
+    if (!sessionStorage.getItem("lattice.releaseEvidence.cleared")) {
+      localStorage.removeItem("lattice.productFlow.complete");
+      localStorage.removeItem("lattice.productFlow.user");
+      localStorage.setItem("lattice.language", "ko");
+      localStorage.setItem("lattice.mode", "advanced");
+      sessionStorage.setItem("lattice.releaseEvidence.cleared", "true");
+    }
+  });
+
+  await page.goto(`${baseURL}/app`, { waitUntil: "networkidle" });
+  const korean = page.getByRole("button", { name: "한국어" });
+  if (await korean.count()) {
+    await korean.click();
+  }
+  await page.getByRole("button", { name: "Brain 지금 깨우기" }).click();
+  await page.getByText("이 Brain의 주인을 정합니다.").waitFor();
+  await shot(page, "01-login.png");
+
+  await page.getByPlaceholder(/You|나/).fill("Codex");
+  await page.getByPlaceholder("you@local").fill("codex@local");
+  await page.getByPlaceholder("로컬 Brain 비밀번호").fill("Lattice123");
+  await page.getByRole("button", { name: "내 Brain 시작하기" }).click();
+  await page.getByText("추천대로 시작하세요.").waitFor();
+  await shot(page, "02-recommended-models.png");
+
+  await page.getByRole("button", { name: "추천으로 바로 시작" }).click();
+  await page.getByText("모델을 준비하고 시작합니다.").waitFor();
+  await page.getByRole("button", { name: "준비하고 시작하기" }).click();
+  await page.waitForTimeout(180);
+  await shot(page, "03-install-load-progress.png");
+  await page.locator("main[aria-label='Lattice Brain']").waitFor();
+  await shot(page, "04-brain-chat-home.png");
+
+  await page.goto(`${baseURL}/app#/knowledge-graph`, { waitUntil: "networkidle" });
+  await page.locator("[data-testid='brain-cytoscape']").waitFor();
+  const graphSearch = page.locator(
+    "input[aria-label='Search knowledge graph'], input[placeholder*='Search'], input[placeholder*='검색']"
+  ).first();
+  if (await graphSearch.count()) {
+    await graphSearch.fill("workspace");
+  }
+  await shot(page, "05-memory-graph.png");
+
+  await page.goto(`${baseURL}/app#/capture`, { waitUntil: "networkidle" });
+  await page.locator("h1.page-title", { hasText: "어떤 자료를 기억할까요?" }).waitFor();
+  await shot(page, "06-capture.png");
+
+  await page.goto(`${baseURL}/app#/models`, { waitUntil: "networkidle" });
+  await page.locator("h1.page-title", { hasText: "Lattice가 사용할 AI를 선택하세요." }).waitFor();
+  await shot(page, "07-model-library.png");
+
+  await page.goto(`${baseURL}/app#/settings`, { waitUntil: "networkidle" });
+  await page.locator("h1.page-title", { hasText: "Lattice를 내 방식에 맞게 설정하세요." }).waitFor();
+  await shot(page, "08-system.png");
+
+  await page.goto(`${baseURL}/app#/brain`, { waitUntil: "networkidle" });
+  await page.locator("main[aria-label='Lattice Brain']").waitFor();
+  await page.getByTestId("brain-knowledge-flow").waitFor();
+  await page.waitForTimeout(250);
+  await shot(page, "09-model-setup-status.png");
+
+  await page.goto(`${baseURL}/app#/admin/users`, { waitUntil: "networkidle" });
+  await page.waitForTimeout(250);
+  await shot(page, "10-admin-console.png");
+
+  await page.goto(`${baseURL}/app#/review`, { waitUntil: "networkidle" });
+  await page.getByText(/Review Center|리뷰 센터|검토함/).first().waitFor();
+  const rawError = page.getByText(/not valid JSON|Unexpected token/);
+  if (await rawError.count()) {
+    throw new Error("Review Center release evidence contains a raw API parse error");
+  }
+  await shot(page, "12-review-center.png");
+
+  const video = page.video();
+  await context.close();
+  await browser.close();
+
+  const recorded = await video.path();
+  const webmTarget = path.join(videos, `v${version}-living-brain-walkthrough.webm`);
+  const gifTarget = path.join(gifs, `v${version}-living-brain-walkthrough.gif`);
+  if (fs.existsSync(webmTarget)) fs.unlinkSync(webmTarget);
+  if (fs.existsSync(gifTarget)) fs.unlinkSync(gifTarget);
+  fs.renameSync(recorded, webmTarget);
+  execFileSync("ffmpeg", [
+    "-y",
+    "-i", webmTarget,
+    "-vf", "fps=8,scale=960:-1:flags=lanczos",
+    "-loop", "0",
+    gifTarget,
+  ], { stdio: "ignore" });
+
+  const index = `# v${version} Release Evidence
+
+Captured from the built React/Vite app served by the release visual API on ${new Date().toISOString()}.
+
+## Screenshots
+
+| File | Flow |
+| --- | --- |
+| [01-login.png](screenshots/01-login.png) | Login |
+| [02-recommended-models.png](screenshots/02-recommended-models.png) | Recommended Models |
+| [03-install-load-progress.png](screenshots/03-install-load-progress.png) | Install & Load progress |
+| [04-brain-chat-home.png](screenshots/04-brain-chat-home.png) | Brain Chat home |
+| [05-memory-graph.png](screenshots/05-memory-graph.png) | Memory Graph |
+| [06-capture.png](screenshots/06-capture.png) | Add Sources |
+| [07-model-library.png](screenshots/07-model-library.png) | Model Library |
+| [08-system.png](screenshots/08-system.png) | System |
+| [09-model-setup-status.png](screenshots/09-model-setup-status.png) | Model setup status |
+| [10-admin-console.png](screenshots/10-admin-console.png) | Separate Admin Console |
+| [12-review-center.png](screenshots/12-review-center.png) | Automation Review Center |
+
+## Motion Evidence
+
+- [v${version}-living-brain-walkthrough.webm](videos/v${version}-living-brain-walkthrough.webm)
+- [v${version}-living-brain-walkthrough.gif](gifs/v${version}-living-brain-walkthrough.gif)
+`;
+  fs.writeFileSync(path.join(root, "SCREENSHOT_INDEX.md"), index);
+}
+
+try {
+  await main();
+} finally {
+  server.kill();
+}