ltcai 10.7.0 → 10.8.0

package/latticeai/core/workspace_os.py

@@ -11,7 +11,6 @@ from __future__ import annotations
 import json
 import shutil
 import sqlite3
-from collections import deque
 from contextlib import contextmanager
 from pathlib import Path
 from typing import Any, Callable, Dict, Iterable, Iterator, List, Optional
@@ -19,8 +18,11 @@ from typing import Any, Callable, Dict, Iterable, Iterator, List, Optional
 from latticeai.core.quiet import quiet
 
 from .timeutil import now_iso as _now
+from .workspace_computer_memory import WorkspaceComputerMemory
 from .workspace_graph_trace import WorkspaceGraphTrace
+from .workspace_indexing import WorkspaceIndexing
 from .workspace_memory import WorkspaceMemory
+from .workspace_onboarding import WorkspaceOnboarding
 from .workspace_os_constants import (
     DEFAULT_WORKSPACE_ID,
     EXECUTION_EVENT_TYPES,
@@ -49,6 +51,8 @@ from .workspace_permissions import (  # type: ignore
     _member_role,
 )
 from .workspace_plugins import WorkspacePluginManager
+from .workspace_relationships import WorkspaceRelationships
+from .workspace_relationships import shortest_path as _shortest_path
 from .workspace_review_items import WorkspaceReviewItems
 from .workspace_runs import WorkspaceRuns
 from .workspace_skills import WorkspaceSkills
@@ -108,6 +112,10 @@ class WorkspaceOSStore:
         self.runs = WorkspaceRuns(self)
         self.review_items = WorkspaceReviewItems(self)
         self.skills = WorkspaceSkills(self)
+        self.indexing = WorkspaceIndexing(self)
+        self.relationships = WorkspaceRelationships(self)
+        self.computer_memory = WorkspaceComputerMemory(self)
+        self.onboarding = WorkspaceOnboarding(self)
 
     @contextmanager
     def _connect_state_db(self) -> Iterator[sqlite3.Connection]:
@@ -552,22 +560,7 @@ class WorkspaceOSStore:
     # ------------------------------------------------------------------
 
     def onboarding_status(self, users: Optional[Dict[str, Any]] = None, graph_stats: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
-        state = self.load_state()
-        users = users or {}
-        admins = [
-            email for email, user in users.items()
-            if isinstance(user, dict) and user.get("role") == "admin"
-        ]
-        onboarding = state.get("onboarding") or {}
-        steps = onboarding.get("steps") or {}
-        return {
-            **onboarding,
-            "steps": [steps.get(step, {"id": step, "status": "pending"}) for step in ONBOARDING_STEPS],
-            "has_account": bool(users),
-            "has_admin": bool(admins) or bool(users),
-            "graph_ready": bool(graph_stats and not graph_stats.get("disabled")),
-            "required_steps": list(ONBOARDING_STEPS),
-        }
+        return self.onboarding.status(users=users, graph_stats=graph_stats)
 
     def update_onboarding_step(
         self,
@@ -578,40 +571,12 @@ class WorkspaceOSStore:
         error: str = "",
         user_email: Optional[str] = None,
     ) -> Dict[str, Any]:
-        if step not in ONBOARDING_STEPS:
-            raise ValueError(f"unknown onboarding step: {step}")
-        if status not in {"pending", "running", "complete", "failed", "skipped"}:
-            raise ValueError(f"unknown onboarding status: {status}")
-        state = self.load_state()
-        onboarding = state.setdefault("onboarding", {})
-        steps = onboarding.setdefault("steps", {})
-        record = steps.setdefault(step, {"id": step})
-        record.update({
-            "id": step,
-            "status": status,
-            "data": data or record.get("data") or {},
-            "error": error,
-            "updated_at": _now(),
-            "user_email": user_email,
-        })
-        if status in {"complete", "skipped"}:
-            index = ONBOARDING_STEPS.index(step)
-            if step == "complete":
-                onboarding["completed"] = True
-                onboarding["completed_at"] = _now()
-                onboarding["current_step"] = "complete"
-            elif index + 1 < len(ONBOARDING_STEPS):
-                onboarding["current_step"] = ONBOARDING_STEPS[index + 1]
-        elif status == "failed":
-            onboarding["current_step"] = step
-        self.save_state(state)
-        self.record_timeline_event("workspace", "onboarding_step", {"step": step, "status": status})
-        return self.onboarding_status()
+        return self.onboarding.update_step(
+            step, status=status, data=data, error=error, user_email=user_email
+        )
 
     def complete_onboarding(self, data: Optional[Dict[str, Any]] = None, user_email: Optional[str] = None) -> Dict[str, Any]:
-        for step in ONBOARDING_STEPS:
-            self.update_onboarding_step(step, status="complete", data=data if step == "complete" else None, user_email=user_email)
-        return self.onboarding_status()
+        return self.onboarding.complete(data=data, user_email=user_email)
 
     # ------------------------------------------------------------------
     # Graph answer traces
@@ -645,76 +610,16 @@ class WorkspaceOSStore:
     # ------------------------------------------------------------------
 
     def build_indexing_dashboard(self, graph: Any, watcher_status: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
-        if graph is None:
-            return {
-                "sources": [],
-                "watcher": watcher_status or {"available": False, "active": {}},
-                "totals": {"success": 0, "failed": 0, "nodes": 0, "edges": 0},
-            }
-        stats = graph.stats()
-        sources = graph.local_sources().get("sources", [])
-        watcher_status = watcher_status or {"available": False, "active": {}}
-        active = watcher_status.get("active", {})
-        dashboard_sources = []
-        total_success = 0
-        total_failed = 0
-        for source in sources:
-            file_status = source.get("file_status") or {}
-            success = int(file_status.get("indexed") or 0)
-            failed = sum(int(file_status.get(key) or 0) for key in ("failed", "inaccessible", "skipped_empty_text"))
-            total_success += success
-            total_failed += failed
-            watch = active.get(source.get("id")) or {}
-            dashboard_sources.append({
-                "id": source.get("id"),
-                "label": source.get("label"),
-                "root_path": source.get("root_path"),
-                "status": source.get("status"),
-                "watch_enabled": bool(source.get("watch_enabled")),
-                "watch_active": source.get("id") in active,
-                "watch_status": watch,
-                "success_count": success,
-                "failure_count": failed,
-                "last_run_at": source.get("last_scanned_at") or source.get("updated_at"),
-                "file_status": file_status,
-                "include_ocr": bool(source.get("include_ocr")),
-            })
-        return {
-            "sources": dashboard_sources,
-            "watcher": watcher_status,
-            "totals": {
-                "success": total_success,
-                "failed": total_failed,
-                "nodes": sum(int(v or 0) for v in (stats.get("nodes") or {}).values()),
-                "edges": sum(int(v or 0) for v in (stats.get("edges") or {}).values()),
-                "local_sources": stats.get("local_sources", len(sources)),
-            },
-            "graph_stats": stats,
-        }
+        return self.indexing.build_dashboard(graph, watcher_status)
 
     def pause_indexing(self, graph: Any, source_id: str, watcher: Any = None) -> Dict[str, Any]:
-        result = graph.set_local_source_watch(source_id, False)
-        watch = watcher.stop_source(source_id) if watcher else {"stopped": False, "source_id": source_id}
-        self.record_timeline_event("graph", "indexing_paused", {"source_id": source_id})
-        return {"status": "ok", "source": result, "watch": watch}
+        return self.indexing.pause(graph, source_id, watcher)
 
     def resume_indexing(self, graph: Any, source_id: str, watcher: Any = None) -> Dict[str, Any]:
-        result = graph.set_local_source_watch(source_id, True)
-        watch = {"watching": False, "source_id": source_id}
-        source = next((item for item in graph.local_sources().get("sources", []) if item.get("id") == source_id), None)
-        if watcher and source:
-            watch = watcher.start_source(source)
-        self.record_timeline_event("graph", "indexing_resumed", {"source_id": source_id})
-        return {"status": "ok", "source": result, "watch": watch}
+        return self.indexing.resume(graph, source_id, watcher)
 
     def remove_index_source(self, graph: Any, source_id: str, watcher: Any = None) -> Dict[str, Any]:
-        if watcher:
-            watcher.stop_source(source_id)
-        if not hasattr(graph, "remove_local_source"):
-            raise ValueError("graph store does not support removing local sources")
-        result = graph.remove_local_source(source_id)
-        self.record_timeline_event("graph", "indexing_removed", {"source_id": source_id})
-        return {"status": "ok", **result}
+        return self.indexing.remove_source(graph, source_id, watcher)
 
     # ------------------------------------------------------------------
     # Snapshots, Time Machine, and diffs
@@ -939,63 +844,11 @@ class WorkspaceOSStore:
     # ------------------------------------------------------------------
 
     def relationship_explorer(self, graph: Any, node_id: str, target_id: Optional[str] = None, limit: int = 500) -> Dict[str, Any]:
-        if graph is None:
-            return {"node_id": node_id, "inbound": [], "outbound": [], "related_entities": [], "shortest_path": []}
-        data = graph.graph(limit=limit)
-        nodes = {node.get("id"): node for node in data.get("nodes") or [] if node.get("id")}
-        edges = data.get("edges") or []
-        inbound = [edge for edge in edges if edge.get("to") == node_id]
-        outbound = [edge for edge in edges if edge.get("from") == node_id]
-        if node_id not in nodes:
-            try:
-                neighbors = graph.neighbors(node_id)
-                for node in neighbors.get("neighbors") or []:
-                    nodes[node.get("id")] = node
-                edges.extend(neighbors.get("edges") or [])
-                inbound = [edge for edge in edges if edge.get("to") == node_id]
-                outbound = [edge for edge in edges if edge.get("from") == node_id]
-            except Exception:
-                quiet()
-
-        related_ids = []
-        for edge in inbound + outbound:
-            other = edge.get("from") if edge.get("to") == node_id else edge.get("to")
-            if other:
-                related_ids.append(other)
-        related = [nodes.get(rid, {"id": rid}) for rid in dict.fromkeys(related_ids)]
-        shortest_path = self._shortest_path(edges, node_id, target_id) if target_id else []
-        return {
-            "node_id": node_id,
-            "node": nodes.get(node_id, {"id": node_id}),
-            "inbound": inbound,
-            "outbound": outbound,
-            "related_entities": related,
-            "shortest_path": shortest_path,
-        }
+        return self.relationships.explore(graph, node_id, target_id=target_id, limit=limit)
 
     @staticmethod
     def _shortest_path(edges: List[Dict[str, Any]], start: str, target: Optional[str]) -> List[str]:
-        if not start or not target:
-            return []
-        adjacency: Dict[str, List[str]] = {}
-        for edge in edges:
-            src = edge.get("from")
-            dst = edge.get("to")
-            if src and dst:
-                adjacency.setdefault(src, []).append(dst)
-                adjacency.setdefault(dst, []).append(src)
-        queue: deque[List[str]] = deque([[start]])
-        seen = {start}
-        while queue:
-            path = queue.popleft()
-            node = path[-1]
-            if node == target:
-                return path
-            for neighbor in adjacency.get(node, []):
-                if neighbor not in seen:
-                    seen.add(neighbor)
-                    queue.append(path + [neighbor])
-        return []
+        return _shortest_path(edges, start, target)
 
     # ------------------------------------------------------------------
     # Local Computer Memory
@@ -1009,48 +862,12 @@ class WorkspaceOSStore:
         consent: Optional[Dict[str, Any]] = None,
         scopes: Optional[List[str]] = None,
     ) -> Dict[str, Any]:
-        consent = consent or {}
-        if enabled and not consent.get("approved"):
-            raise PermissionError("Local Computer Memory requires explicit approval.")
-        state = self.load_state()
-        config = state.setdefault("computer_memory", {})
-        config.update({
-            "enabled": bool(enabled),
-            "approved": bool(enabled),
-            "approved_at": _now() if enabled else config.get("approved_at"),
-            "approved_by": approved_by if enabled else config.get("approved_by"),
-            "scopes": scopes or config.get("scopes") or ["Downloads", "Documents", "Repositories"],
-            "consent": consent,
-        })
-        state.setdefault("feature_flags", {})["local_computer_memory"] = bool(enabled)
-        self.save_state(state)
-        self.record_timeline_event("memory", "computer_memory_configured", {"enabled": bool(enabled), "approved_by": approved_by})
-        return config
+        return self.computer_memory.configure(
+            enabled=enabled, approved_by=approved_by, consent=consent, scopes=scopes
+        )
 
     def record_computer_activity(self, activity: Dict[str, Any], graph: Any = None) -> Dict[str, Any]:
-        state = self.load_state()
-        config = state.setdefault("computer_memory", {})
-        if not config.get("enabled"):
-            return {"status": "ignored", "reason": "local computer memory is disabled"}
-        record = {
-            "id": f"activity-{_json_hash([activity, _now()])[:16]}",
-            "timestamp": _now(),
-            **activity,
-        }
-        config.setdefault("activities", []).append(record)
-        if graph is not None:
-            try:
-                graph.ingest_event(
-                    "ComputerActivity",
-                    str(activity.get("summary") or activity.get("path") or "Computer activity")[:120],
-                    source="workspace_os",
-                    metadata=record,
-                )
-            except Exception as exc:
-                record["graph_error"] = str(exc)
-        self.save_state(state)
-        self.record_timeline_event("memory", "computer_activity", {"activity_id": record["id"]})
-        return {"status": "ok", "activity": record}
+        return self.computer_memory.record_activity(activity, graph)
 
     # ------------------------------------------------------------------
     # Skills

package/latticeai/core/workspace_os_constants.py

@@ -10,7 +10,7 @@ from __future__ import annotations
 
 from typing import Dict
 
-WORKSPACE_OS_VERSION = "10.7.0"
+WORKSPACE_OS_VERSION = "10.8.0"
 
 # Workspace types separate single-user Personal workspaces from shared
 # Organization workspaces. Both keep the same local-first JSON store; the type

package/latticeai/core/workspace_relationships.py

@@ -0,0 +1,99 @@
+"""Relationship explorer: what a node connects to, and the way between two.
+
+Extracted from ``WorkspaceOSStore``. Pure graph reading — it touches no state
+file and records no events, so it holds no reference to the store at all.
+"""
+
+from __future__ import annotations
+
+from collections import deque
+from typing import Any, Dict, List, Optional
+
+from latticeai.core.quiet import quiet
+
+__all__ = ["WorkspaceRelationships", "shortest_path"]
+
+
+def shortest_path(edges: List[Dict[str, Any]], start: str, target: Optional[str]) -> List[str]:
+    """Fewest-hops path between two nodes, treating every edge as undirected.
+
+    Breadth-first, so the first arrival at ``target`` is a shortest one.
+    Returns ``[]`` when either end is missing or nothing connects them.
+    """
+    if not start or not target:
+        return []
+    adjacency: Dict[str, List[str]] = {}
+    for edge in edges:
+        src = edge.get("from")
+        dst = edge.get("to")
+        if src and dst:
+            adjacency.setdefault(src, []).append(dst)
+            adjacency.setdefault(dst, []).append(src)
+    queue: deque[List[str]] = deque([[start]])
+    seen = {start}
+    while queue:
+        path = queue.popleft()
+        node = path[-1]
+        if node == target:
+            return path
+        for neighbor in adjacency.get(node, []):
+            if neighbor not in seen:
+                seen.add(neighbor)
+                queue.append(path + [neighbor])
+    return []
+
+
+class WorkspaceRelationships:
+    """Answers "what is this connected to" for one node of the graph."""
+
+    def __init__(self, store: Any) -> None:
+        self.store = store
+
+    def explore(
+        self,
+        graph: Any,
+        node_id: str,
+        target_id: Optional[str] = None,
+        limit: int = 500,
+    ) -> Dict[str, Any]:
+        if graph is None:
+            return {
+                "node_id": node_id,
+                "inbound": [],
+                "outbound": [],
+                "related_entities": [],
+                "shortest_path": [],
+            }
+        data = graph.graph(limit=limit)
+        nodes = {node.get("id"): node for node in data.get("nodes") or [] if node.get("id")}
+        edges = data.get("edges") or []
+        inbound = [edge for edge in edges if edge.get("to") == node_id]
+        outbound = [edge for edge in edges if edge.get("from") == node_id]
+        # The capped `graph(limit=…)` window may not contain this node at all.
+        # Asking the store for its neighbours directly is the difference between
+        # "not connected" and "outside the page we happened to fetch".
+        if node_id not in nodes:
+            try:
+                neighbors = graph.neighbors(node_id)
+                for node in neighbors.get("neighbors") or []:
+                    nodes[node.get("id")] = node
+                edges.extend(neighbors.get("edges") or [])
+                inbound = [edge for edge in edges if edge.get("to") == node_id]
+                outbound = [edge for edge in edges if edge.get("from") == node_id]
+            except Exception:
+                quiet()
+
+        related_ids = []
+        for edge in inbound + outbound:
+            other = edge.get("from") if edge.get("to") == node_id else edge.get("to")
+            if other:
+                related_ids.append(other)
+        related = [nodes.get(rid, {"id": rid}) for rid in dict.fromkeys(related_ids)]
+        return {
+            "node_id": node_id,
+            "node": nodes.get(node_id, {"id": node_id}),
+            "inbound": inbound,
+            "outbound": outbound,
+            "related_entities": related,
+            "shortest_path": shortest_path(edges, node_id, target_id) if target_id else [],
+        }

package/latticeai/services/architecture_readiness.py

@@ -16,7 +16,7 @@ from typing import Any, Dict, List
 
 from latticeai.core.legacy_compatibility import legacy_shim_report
 
-ARCHITECTURE_VERSION_TARGET = "10.7.0"
+ARCHITECTURE_VERSION_TARGET = "10.8.0"
 
 PREFERRED_REFACTORING_ORDER = [
     "agent-runtime",

package/latticeai/services/product_readiness.py

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ltcai",
-  "version": "10.7.0",
+  "version": "10.8.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": {

package/scripts/check_current_release_docs.mjs

@@ -6,7 +6,7 @@ const root = process.cwd();
 const pkg = JSON.parse(readFileSync(path.join(root, "package.json"), "utf8"));
 const version = pkg.version;
 const releaseDir = `output/release/v${version}`;
-const releaseTheme = "Plain Surface";
+const releaseTheme = "Within Reach";
 const title = `${version} — ${releaseTheme}`;
 const escapedVersion = version.replaceAll(".", "\\.");
 

package/scripts/check_screenshot_pixel_delta.py

@@ -279,8 +279,18 @@ def _default_baseline(root: Path, current: Path) -> Optional[Path]:
     return path
 
 
-def _pixel_delta_pct(a: Path, b: Path) -> Tuple[float, int, int, int, int]:
-    """Return (changed_pct, changed_px, total_px, height_a, height_b)."""
+def _pixel_delta_pct(
+    a: Path,
+    b: Path,
+    region: Optional[List[float]] = None,
+) -> Tuple[float, int, int, int, int]:
+    """Return (changed_pct, changed_px, total_px, height_a, height_b).
+
+    ``region`` is ``[x0, y0, x1, y1]`` as fractions of the aligned canvas. It
+    narrows the comparison to the part of the screen a release says it
+    changed, so an animated element elsewhere cannot mask a real change — or
+    manufacture one. Heights are always reported for the full images.
+    """
     with Image.open(a) as im_a, Image.open(b) as im_b:
         im_a = im_a.convert("RGB")
         im_b = im_b.convert("RGB")
@@ -292,6 +302,18 @@ def _pixel_delta_pct(a: Path, b: Path) -> Tuple[float, int, int, int, int]:
         canvas_b = Image.new("RGB", (w, h), (0, 0, 0))
         canvas_a.paste(im_a, (0, 0))
         canvas_b.paste(im_b, (0, 0))
+        if region:
+            x0, y0, x1, y1 = region
+            box = (
+                max(0, min(w, int(round(w * x0)))),
+                max(0, min(h, int(round(h * y0)))),
+                max(0, min(w, int(round(w * x1)))),
+                max(0, min(h, int(round(h * y1)))),
+            )
+            if box[2] > box[0] and box[3] > box[1]:
+                canvas_a = canvas_a.crop(box)
+                canvas_b = canvas_b.crop(box)
+                w, h = canvas_a.size
         diff = ImageChops.difference(canvas_a, canvas_b)
         # Any channel delta > 8 counts as changed (ignore sub-pixel AA noise).
         # Count on RGB getdata: a pixel is changed if any channel exceeds the
@@ -304,6 +326,33 @@ def _pixel_delta_pct(a: Path, b: Path) -> Tuple[float, int, int, int, int]:
         return pct, changed, total, h_a, h_b
 
 
+CLAIMS_PATH = "scripts/release_screen_claims.json"
+
+
+def _load_screen_claims(root: Path, version: str) -> Optional[Dict[str, Dict[str, object]]]:
+    """What this release says it changed, or None for "all twelve".
+
+    A version with no entry is gated on every screen, so forgetting to write a
+    claim makes this check stricter rather than weaker.
+    """
+    path = root / CLAIMS_PATH
+    if not path.is_file():
+        return None
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except ValueError as exc:
+        print(f"pixel delta: {CLAIMS_PATH} is not valid JSON ({exc})", file=sys.stderr)
+        return None
+    entry = data.get(_normalize_version(version))
+    if not isinstance(entry, dict):
+        return None
+    return {
+        name: (options if isinstance(options, dict) else {})
+        for name, options in entry.items()
+        if name in SHOTS
+    }
+
+
 def main(argv: Optional[List[str]] = None) -> int:
     root = _repo_root()
     parser = argparse.ArgumentParser(description=__doc__)
@@ -379,10 +428,21 @@ def main(argv: Optional[List[str]] = None) -> int:
     )
     print("-" * 64)
 
+    claims = _load_screen_claims(root, _package_version(root))
+    if claims is None:
+        print(f"pixel delta: no claim for this version in {CLAIMS_PATH} — gating all {len(SHOTS)} screens")
+    else:
+        print(
+            f"pixel delta: gating {len(claims)} claimed screen(s); "
+            f"{len(SHOTS) - len(claims)} unclaimed screen(s) measured but not gated"
+        )
+
     failures: List[str] = []
     results: List[Dict[str, object]] = []
 
     for name in SHOTS:
+        claimed = claims is None or name in SHOTS and name in claims
+        options = (claims or {}).get(name, {}) if claims is not None else {}
         cur = current / name
         base = baseline / name
         if not cur.is_file():
@@ -394,19 +454,27 @@ def main(argv: Optional[List[str]] = None) -> int:
             print(f"{name:<32} {'—':>8} {'—':>6} {'—':>6} FAIL")
             continue
 
-        pct, changed, total, h_cur, h_base = _pixel_delta_pct(cur, base)
+        region = options.get("region") if isinstance(options.get("region"), list) else None
+        pct, changed, total, h_cur, h_base = _pixel_delta_pct(cur, base, region)
         height_delta = abs(h_cur - h_base)
         live = name in LIVING_BRAIN
-        min_pct = args.min_pct_live if live else args.min_pct
+        # A claim that names its region has already excluded the animated part
+        # of the screen, so the live threshold no longer buys anything there.
+        default_min = args.min_pct_live if (live and not region) else args.min_pct
+        override = options.get("min_pct")
+        min_pct = float(override) if isinstance(override, (int, float)) else default_min
         # Height growth alone proves layout rebuild for full-page shots.
-        ok = pct >= min_pct or height_delta >= args.min_height_px
-        tag = "ok" if ok else "FAIL"
-        if not ok:
+        moved = pct >= min_pct or height_delta >= args.min_height_px
+        ok = moved or not claimed
+        tag = "ok" if moved else ("—" if not claimed else "FAIL")
+        if claimed and not moved:
             failures.append(
                 f"{name}: pixel={pct:.2f}% (need>={min_pct:.1f}%) "
                 f"height_delta={height_delta}px (need>={args.min_height_px})"
+                + (f" region={region}" if region else "")
             )
-        print(f"{name:<32} {pct:7.2f}% {height_delta:5d}p {min_pct:5.1f}% {tag:>5}")
+        marker = "" if claimed else " (unclaimed)"
+        print(f"{name:<32} {pct:7.2f}% {height_delta:5d}p {min_pct:5.1f}% {tag:>5}{marker}")
         results.append(
             {
                 "file": name,
@@ -416,18 +484,32 @@ def main(argv: Optional[List[str]] = None) -> int:
                 "height_delta": height_delta,
                 "min_pct": min_pct,
                 "living_brain": live,
+                "region": region,
+                "claimed": claimed,
+                "moved": moved,
                 "pass": ok,
             }
         )
 
     print("-" * 64)
+    gated = sum(1 for item in results if item["claimed"])
     if failures:
-        print(f"pixel delta: FAIL — {len(failures)}/{len(SHOTS)} screen(s) below threshold")
+        print(f"pixel delta: FAIL — {len(failures)}/{gated} claimed screen(s) below threshold")
         for item in failures:
             print(f"  - {item}", file=sys.stderr)
         return 1
 
-    print(f"pixel delta: PASS — all {len(SHOTS)} screens moved enough vs baseline v{expected_version}")
+    # An unclaimed screen that moved is not a failure, but it is worth saying:
+    # it is either an unintended side effect or a claim someone forgot to write.
+    surprises = [
+        f"{item['file']} ({item['pixel_pct']:.2f}%)"
+        for item in results
+        if not item["claimed"] and item["moved"]
+    ]
+    if surprises:
+        print(f"pixel delta: note — unclaimed screens that changed anyway: {', '.join(surprises)}")
+
+    print(f"pixel delta: PASS — all {gated} claimed screen(s) moved vs baseline v{expected_version}")
     return 0
 
 

package/scripts/release_screen_claims.json

@@ -0,0 +1,37 @@
+{
+  "_comment": [
+    "Which screens each release claims to have changed, and where.",
+    "",
+    "The pixel gate used to require all twelve screens to move on every",
+    "release. That was right for 10.6.x/10.7.0, which were explicitly",
+    "'rearrange every screen' releases, and wrong as a standing rule: a",
+    "release that deliberately touches four screens would have to churn the",
+    "other eight or fail — which is the dishonesty the gate exists to catch,",
+    "inverted.",
+    "",
+    "A release lists the screens it claims to have changed. Claimed screens",
+    "are gated exactly as before. Unclaimed screens are still measured and",
+    "printed, so an unintended change is visible, but do not fail the run.",
+    "A version with no entry here is gated on all twelve — forgetting to",
+    "write a claim makes the gate stricter, never weaker.",
+    "",
+    "'region' narrows the comparison to [x0, y0, x1, y1] as fractions of the",
+    "image. Use it when a screen carries an animated element that dominates a",
+    "whole-image delta: naming where the change is makes the claim more",
+    "specific, not less."
+  ],
+
+  "10.8.0": {
+    "01-login.png": {},
+    "02-recommended-models.png": {},
+    "03-install-load-progress.png": {},
+    "05-memory-graph.png": {
+      "_why": "The provenance meter in this screen's header wrapped into a ragged three-line block that ran into the page title. It is a bordered column with a straight left edge now."
+    },
+    "04-brain-chat-home.png": {
+      "_why": "The Brain organism sits in this screen's greeting banner and moved 7.34% of that band between 10.6.3 and 10.7.0 with no layout intent, which is why 04 carries the 8% live threshold. 10.8.0 changed the suggestion deck and the shelf row below the composer; measuring that region directly is both stricter (the claim names where) and able to see a change the whole-image metric cannot.",
+      "region": [0.0, 0.45, 1.0, 0.85],
+      "min_pct": 1.5
+    }
+  }
+}

package/src-tauri/Cargo.lock

@@ -1584,7 +1584,7 @@ dependencies = [
 
 [[package]]
 name = "lattice-ai-desktop"
-version = "10.7.0"
+version = "10.8.0"
 dependencies = [
  "plist",
  "serde",