ltcai 7.8.0 → 8.0.0

package/README.md

@@ -1,6 +1,6 @@
 # Lattice AI
 
-**Lattice AI 7.8 is the glanceable local-first Digital Brain product. It keeps your knowledge durable across any AI model, with Brain Chat Home rebuilt around immediate use instead of dashboard clutter.**
+**Lattice AI 8.0 is the local-first Digital Brain platform with hardened runtime architecture. It keeps your knowledge durable across any AI model, with AgentRuntime, ToolRegistry, central Config, and Knowledge Graph stability tracked by explicit release contracts.**
 
 **Lattice AI는 모델이 바뀌어도 내 지식과 맥락을 보존하는 로컬 우선 AI 브레인입니다.**
 
@@ -11,7 +11,7 @@ downloads, update checks, and other external communication happen only after
 explicit consent.
 
 It is not a ChatGPT clone, a model launcher, a graph database, or a note app.
-It is the finished private AI memory layer wrapped in a Living Brain experience — now with a cleaner 7.8 Brain Chat Home.
+It is the finished private AI memory layer wrapped in a Living Brain experience — now with the 8.0 runtime architecture contract behind it.
 
 [![PyPI Version](https://img.shields.io/pypi/v/ltcai?label=PyPI)](https://pypi.org/project/ltcai/)
 [![npm Version](https://img.shields.io/npm/v/ltcai?label=npm)](https://www.npmjs.com/package/ltcai)
@@ -64,7 +64,7 @@ You need Lattice AI when:
 
 ## Living Brain Flow
 
-The screenshots below are release evidence captures. The 7.8 line keeps the
+The screenshots below are release evidence captures. The 8.0 line keeps the
 same first-run flow and rebuilds the Brain Chat Home layout so chat and the
 composer are the first visible action.
 
@@ -78,28 +78,28 @@ confirm owner, check the computer, choose the Brain voice.
 Choose the owner of the Brain. The profile is not a SaaS account by default; it
 is the local identity for the knowledge you keep.
 
-![Login](output/release/v7.7.0/screenshots/01-login.png)
+![Login](output/release/v7.8.0/screenshots/01-login.png)
 
 ### 3. Environment Analysis
 
 See what kind of local AI experience this computer can support before choosing a
 model.
 
-![Environment Analysis](output/release/v7.7.0/screenshots/02-environment-analysis.png)
+![Environment Analysis](output/release/v7.8.0/screenshots/02-environment-analysis.png)
 
 ### 4. Recommended Models
 
 Start with a short list: safest recommendation, faster model, stronger model.
 Advanced details stay available without overwhelming first-time users.
 
-![Recommended Models](output/release/v7.7.0/screenshots/03-recommended-models.png)
+![Recommended Models](output/release/v7.8.0/screenshots/03-recommended-models.png)
 
 ### 5. Install And Load
 
 Download and load only after consent. Lattice explains model size, local
 execution, and network use before work starts.
 
-![Install and Load](output/release/v7.7.0/screenshots/04-install-load-progress.png)
+![Install and Load](output/release/v7.8.0/screenshots/04-install-load-progress.png)
 
 ### 6. Brain Chat
 
@@ -107,14 +107,14 @@ Talk normally. Useful decisions and context become memory, then appear later as
 topics, relationships, graph structure, and the concentric memory rings around
 the Brain.
 
-![Brain Chat Home](output/release/v7.7.0/screenshots/05-brain-chat-home.png)
+![Brain Chat Home](output/release/v7.8.0/screenshots/05-brain-chat-home.png)
 
 ### 7. Review Center
 
 Automation results are staged for review before they become durable decisions.
 Snooze, unsnooze, run now, approve, and dismiss actions stay explicit.
 
-![Review Center](output/release/v7.7.0/screenshots/13-review-center.png)
+![Review Center](output/release/v7.8.0/screenshots/13-review-center.png)
 
 ## Brain Depths
 
@@ -130,10 +130,10 @@ The user travels inward from everyday memory to deeper structure:
 
 Walkthrough:
 
-![v7.7.0 Living Brain walkthrough](output/release/v7.7.0/gifs/v7.7.0-living-brain-walkthrough.gif)
+![v7.8.0 Living Brain walkthrough](output/release/v7.8.0/gifs/v7.8.0-living-brain-walkthrough.gif)
 
 Screenshot index and capture notes:
-[output/release/v7.7.0/SCREENSHOT_INDEX.md](output/release/v7.7.0/SCREENSHOT_INDEX.md)
+[output/release/v7.8.0/SCREENSHOT_INDEX.md](output/release/v7.8.0/SCREENSHOT_INDEX.md)
 
 ## Install
 
@@ -210,33 +210,39 @@ See [docs/DEVELOPMENT.md](docs/DEVELOPMENT.md) for developer workflow details.
 
 ## Current Release
 
-The current release is **7.8.0 — Brain Chat Home UX Simplification**:
-
-- Brain Chat Home now opens with chat, starter prompts, and the composer as the
-  first action. Source ingestion, readiness, proof, timeline, and care controls
-  move behind a single utility drawer instead of occupying the first viewport.
-- The default Brain surface now keeps workspace navigation visible, removes
-  permanent marketing intro copy, and only reveals deep memory controls after
-  the user chooses to travel deeper.
-- Obsolete Brain conversation and first-run guide components were removed so the
-  canonical Brain/onboarding implementation is the only path.
+The current release is **8.0.0 — Runtime Architecture Contract**:
+
+- `architecture_readiness()` now emits `lattice-architecture-contract/v1`,
+  including the preferred refactoring order and concrete ownership for
+  AgentRuntime, ToolRegistry, central Config, server decomposition, and KG
+  hardening.
+- The product AgentRuntime facade in `lattice_brain.runtime.agent_runtime`
+  remains the unambiguous `/agents` execution and observability boundary.
+- ToolRegistry manifest output now carries `tool-registry-contract/v1` with
+  dispatch, policy, and permission ownership, so runtime/admin surfaces can
+  detect catalog drift from one source of truth.
+- Knowledge Graph hardening is represented as an additive reprojection strategy
+  with legacy read compatibility and non-destructive rollback/export paths.
+- KG v2 read-equivalence is locked for document listing, node lookup,
+  relationship search, and traversal, while logical imports preserve colliding
+  legacy edge labels without breaking native canonical dedupe.
 - Product readiness is machine-checkable through `product_readiness()`, which
   composes the architecture contract with exact artifact/docs/workflow evidence.
-- CI and release workflows now run frontend lint/typecheck/build gates plus the
-  7.8 product readiness score before a tag can be treated as release-safe.
+- CI and release workflows continue to run frontend lint/typecheck/build gates
+  plus the 8.0 product readiness score before a tag can be treated as release-safe.
 
-Expected artifacts for 7.8.0 release must use exact filenames:
+Expected artifacts for 8.0.0 release must use exact filenames:
 
-- `dist/ltcai-7.8.0-py3-none-any.whl`
-- `dist/ltcai-7.8.0.tar.gz`
-- `ltcai-7.8.0.tgz`
-- `dist/ltcai-7.8.0.vsix`
-- `src-tauri/target/release/bundle/dmg/Lattice AI_7.8.0_aarch64.dmg`
+- `dist/ltcai-8.0.0-py3-none-any.whl`
+- `dist/ltcai-8.0.0.tar.gz`
+- `ltcai-8.0.0.tgz`
+- `dist/ltcai-8.0.0.vsix`
+- `src-tauri/target/release/bundle/dmg/Lattice AI_8.0.0_aarch64.dmg`
 
-Do not upload `dist/*`. Package registry publishing remains owner-run.
+Do not use wildcard artifact uploads. Package registry publishing remains owner-run.
 
 See [docs/ROADMAP_RECOMMENDATIONS.md](docs/ROADMAP_RECOMMENDATIONS.md) for the
-strategic roadmap slices applied through 7.8.0 and the follow-up tracks.
+strategic roadmap slices applied through 8.0.0 and the follow-up tracks.
 
 ## Known Limitations
 
@@ -253,6 +259,8 @@ strategic roadmap slices applied through 7.8.0 and the follow-up tracks.
 
 | Version | Theme |
 | --- | --- |
+| 8.0.0 | Runtime Architecture Contract: AgentRuntime, ToolRegistry, central Config, server decomposition, and KG hardening are captured as machine-checkable release boundaries with exact 8.0.0 artifacts |
+| 7.9.0 | Agent Runtime Boundary Hardening: explicit `SingleAgentRuntime`, compatibility alias preservation, injected rollback port, and release/readiness docs aligned to the product AgentRuntime facade |
 | 7.8.0 | Brain Chat Home UX Simplification: chat-first first viewport, visible workspace navigation, collapsed source/status utilities, hidden default depth controls, and removal of obsolete Brain UX components |
 | 7.7.0 | Complete Product Polish: command-center Brain Home, repaired Review Center evidence, exact 7.7 docs/artifacts, product readiness gate, and stronger CI/release checks |
 | 7.6.0 | Brain-Centered UX & Architecture Closure: Wake Brain first-run surface, concentric memory rings with direct depth controls, and machine-checkable closure of the two architecture/UX review files |

package/docs/CHANGELOG.md

@@ -6,6 +6,42 @@ existed at that release.
 
 ## [Unreleased]
 
+## [8.0.0] - 2026-06-24
+
+### Changed
+- Added `lattice-architecture-contract/v1` to make the AgentRuntime,
+  ToolRegistry, Config, server decomposition, and Knowledge Graph stabilization
+  boundaries explicit and testable for the major architecture line.
+- Added `tool-registry-contract/v1` to the ToolRegistry manifest, including
+  dispatch, policy, and permission ownership.
+- Updated architecture and product readiness targets to 8.0.0.
+- Synchronized package/runtime/static/Tauri metadata to 8.0.0.
+- Updated current-release docs and exact artifact names to 8.0.0 while
+  preserving historical 7.x entries.
+
+### Fixed
+- Made logical Knowledge Graph `replace` imports transactional so malformed
+  imports roll back without clearing the existing graph.
+- Locked v2 read-equivalence coverage for `list_documents`, `get_node`,
+  `relationship_search`, and `traverse`.
+- Preserved colliding legacy edge labels during logical import/backfill while
+  keeping native write-door synonym dedupe canonical.
+
+## [7.9.0] - 2026-06-23
+
+### Changed
+- Added `SingleAgentRuntime` as the explicit name for the legacy single-agent
+  state machine while preserving `AgentRuntime` as a compatibility alias.
+- Updated tool dispatch to build `SingleAgentRuntime` directly.
+- Moved single-agent git rollback behind an injected `rollback_file` port owned
+  by `ToolDispatchService`, keeping shell execution out of the core state
+  machine.
+- Added a shared `runtime-boundary/v1` descriptor so product and single-agent
+  runtime boundaries are machine-readable in config/tests.
+- Added `RuntimeBoundaryProtocol` as the minimal shared inspection surface for
+  runtime-boundary-aware dependency injection.
+- Updated architecture and product readiness targets to 7.9.0.
+
 ## [7.8.0] - 2026-06-22
 
 ### Changed
@@ -23,6 +59,8 @@ existed at that release.
 - Moved draft onboarding polish out of inline styles and into the shared design
   stylesheet with responsive behavior and bilingual copy.
 - Updated architecture and product readiness targets to 7.8.0.
+- Refreshed 7.8.0 release screenshots, walkthrough video/GIF, and capture
+  notes under `output/release/v7.8.0/`.
 
 ## [7.7.0] - 2026-06-22
 

package/docs/DEVELOPMENT.md

@@ -95,5 +95,4 @@ For user-facing, API, runtime, release, or packaging changes, check:
 - `docs/LEGACY_COMPATIBILITY.md` when root compatibility files change
 
 Release/publish examples must use exact target-version filenames. Do not
-document wildcard upload commands such as `dist/*`.
-
+document wildcard artifact upload commands.

package/docs/MULTI_AGENT_RUNTIME.md

@@ -2,7 +2,7 @@
 
 The Multi-Agent Runtime is the **orchestration layer** introduced in v2.0.0 and
 operationalized in v2.2.0. It sits
-*above* the v1.x single-agent state machine ([`AgentRuntime`](../latticeai/core/agent.py))
+*above* the v1.x single-agent state machine ([`SingleAgentRuntime`](../latticeai/core/agent.py))
 and coordinates a pipeline of named **roles** that hand off work to one another,
 retry on a failing review, and emit a fully observable, replayable timeline.
 
@@ -34,20 +34,21 @@ objects durable and inspectable:
 
 ## How it relates to the v1 single-agent runtime
 
-v1.x shipped a single-agent state machine — `AgentRuntime` driving
+v1.x shipped a single-agent state machine — `SingleAgentRuntime` driving
 `PLAN → EXECUTE → VERIFY → DONE` (with `ROLLBACK` / `FAILED` recovery paths) over an
-injected `AgentDeps` port. That runtime is unchanged.
+injected `AgentDeps` port. The historical `AgentRuntime` import remains as a
+compatibility alias.
 
 v2.0 adds the *orchestration* layer on top: instead of one agent looping through
 internal phases, the `MultiAgentOrchestrator` drives a **pipeline of distinct roles**
 (researcher, planner, executor, reviewer, release) that hand off to one another and
 can rewind on a failing review. The two layers are complementary — the v2
 orchestrator coordinates roles; an individual role's runner could itself be backed by
-the v1 `AgentRuntime` loop or an LLM, but that is an implementation choice behind the
+the v1 `SingleAgentRuntime` loop or an LLM, but that is an implementation choice behind the
 injected runner port.
 
 > **Compatibility.** The Multi-Agent Runtime is purely additive. The v1
-> `AgentRuntime` state machine and its `/agent` endpoints are untouched, and the v2
+> `SingleAgentRuntime` state machine and its `/agent` endpoints are untouched, and the v2
 > API is namespaced under `/agents` (plural) so it never collides with the existing
 > single-agent `/agent` routes. Existing v1.x data is preserved; new runs are appended
 > to workspace state and the Knowledge Graph alongside it.

package/docs/V2_ARCHITECTURE.md

@@ -141,8 +141,9 @@ portable JSON representation (definition only — no run history or scope).
 
 ### 1.3 Multi-Agent Runtime 2.0 (`latticeai.core.multi_agent`)
 
-v1.x shipped a single-agent state machine (`latticeai.core.agent.AgentRuntime`:
-PLAN → EXECUTE → VERIFY → DONE). v2.0 adds the **orchestration** layer above it:
+v1.x shipped a single-agent state machine (`latticeai.core.agent.SingleAgentRuntime`;
+`latticeai.core.agent.AgentRuntime` remains a compatibility alias) that drives
+PLAN → EXECUTE → VERIFY → DONE. v2.0 adds the **orchestration** layer above it:
 a pipeline of named roles that hand off to one another, retry on a failing
 review, and emit a structured timeline that drops straight into the Workspace
 timeline / Knowledge Graph.

package/lattice_brain/__init__.py

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

package/lattice_brain/graph/projection.py

@@ -331,17 +331,31 @@ class KnowledgeGraphProjectionMixin:
         edge_id: Optional[str] = None,
         created_at: Optional[str] = None,
         strict: bool = False,
+        legacy_type: Optional[str] = None,
     ) -> None:
         if KGStoreV2 is None:
             if strict:
                 raise RuntimeError("Knowledge Graph v2 schema is unavailable")
             return
-        eid = (
-            edge_id or f"edge:{_sha256_text(f'{from_node}|{edge_type}|{to_node}')[:24]}"
-        )
+        explicit_legacy_type = legacy_type is not None
+        leg_type = legacy_type if explicit_legacy_type else edge_type
+        # Native canonical writes (and write-door dedupes) use legacy_type=''
+        # so (source,target,type) is the effective key.
+        # Import paths can pass distinct legacy_type to keep colliding legacy
+        # labels as separate rows (lossless for old data).
+        if leg_type and EdgeType is not None:
+            try:
+                if EdgeType.from_legacy(leg_type).value == leg_type:
+                    leg_type = ""
+            except ValueError:
+                pass
         norm_type = (
             EdgeType.from_legacy(edge_type).value if EdgeType is not None else edge_type
         )
+        if explicit_legacy_type and leg_type:
+            eid = f"edge:{_sha256_text(f'{from_node}|{norm_type}|{to_node}|{leg_type}')[:24]}"
+        else:
+            eid = edge_id or f"edge:{_sha256_text(f'{from_node}|{norm_type}|{to_node}')[:24]}"
         meta_str = metadata_json if metadata_json is not None else "{}"
         confidence = float(_safe_loads(meta_str).get("confidence", 1.0))
         try:
@@ -360,7 +374,7 @@ class KnowledgeGraphProjectionMixin:
                     from_node,
                     to_node,
                     norm_type,
-                    edge_type,
+                    leg_type,
                     float(weight),
                     confidence,
                     meta_str,
@@ -371,7 +385,7 @@ class KnowledgeGraphProjectionMixin:
             # (the UNIQUE upsert + weight=max alone would erase recurrence).
             row = conn.execute(
                 "SELECT id FROM edges_v2 WHERE source=? AND target=? AND type=? AND legacy_type=?",
-                (from_node, to_node, norm_type, edge_type),
+                (from_node, to_node, norm_type, leg_type),
             ).fetchone()
             if row is not None:
                 conn.execute(

package/lattice_brain/graph/provenance.py

@@ -292,10 +292,24 @@ class KnowledgeGraphProvenanceMixin:
             plan["dry_run"] = True
             return plan
 
-        if mode == "replace":
-            self.clear_all()
-
         with self._connect() as conn:
+            if mode == "replace":
+                # Keep replacement imports transactional. The old clear_all()
+                # path committed before the import started, so a malformed
+                # artifact could leave a cleared or partially rebuilt graph.
+                # These deletes roll back with the rest of the import.
+                for table in (
+                    "local_file_index",
+                    "knowledge_sources",
+                    "chunks",
+                    "edges",
+                    "nodes",
+                    "vector_embeddings",
+                ):
+                    conn.execute(f"DELETE FROM {table}")
+                if KGStoreV2 is not None:
+                    conn.execute("DELETE FROM edges_v2")
+                    conn.execute("DELETE FROM nodes_v2")
             for n in nodes:
                 self._upsert_node(
                     conn,
@@ -315,13 +329,21 @@ class KnowledgeGraphProvenanceMixin:
                     metadata=_safe_loads(c.get("metadata_json")),
                 )
             for e in edges:
+                e_meta = _safe_loads(e.get("metadata_json")) or {}
+                leg_label = e_meta.get("legacy_label")
+                if not leg_label:
+                    orig = e.get("type") or ""
+                    if orig:
+                        # preserve whatever label came from export (legacy or canon)
+                        leg_label = orig
                 self._upsert_edge(
                     conn,
                     e["from_node"],
                     e["to_node"],
                     e["type"],
                     weight=float(e.get("weight") or 1.0),
-                    metadata=_safe_loads(e.get("metadata_json")),
+                    metadata=e_meta,
+                    legacy_label=leg_label,
                 )
             for s in sources:
                 conn.execute(

package/lattice_brain/graph/write_master.py

@@ -73,20 +73,46 @@ class KnowledgeGraphWriteMixin:
         edge_type: str,
         weight: float = 1.0,
         metadata: Optional[Dict[str, Any]] = None,
+        *,
+        legacy_label: Optional[str] = None,
     ) -> str:
         # v4 write door: every new edge stores the canonical EdgeType value —
         # free-string types (e.g. '포함함', '언급함') are normalized here, so no
         # caller can mint new legacy taxonomy. The original label survives in
         # metadata.legacy_label for traceability.
+        #
+        # legacy_type in edges_v2:
+        #   - normal write door: synonyms always dedupe to ONE row with legacy_type=''
+        #   - import (passes legacy_label=) : preserves distinct legacy labels as
+        #     separate v2 rows (lossless collision for old artifacts / backfill)
+        passed_for_legacy = legacy_label or edge_type
         if EdgeType is not None:
             canonical = EdgeType.from_legacy(edge_type).value
-            if canonical != edge_type:
+            if canonical != edge_type or (legacy_label and legacy_label != canonical):
                 metadata = dict(metadata or {})
-                metadata.setdefault("legacy_label", edge_type)
+                ll = legacy_label or edge_type
+                if ll != canonical:
+                    metadata.setdefault("legacy_label", ll)
             edge_type = canonical
         edge_id = f"edge:{_sha256_text(f'{from_node}|{edge_type}|{to_node}')[:24]}"
         now = _now()
         meta_json = _json(metadata)  # canonical string shared with the projection
+        v2_legacy = ""
+        if passed_for_legacy and passed_for_legacy != edge_type:
+            if legacy_label is not None:
+                # explicit legacy_label from import path forces distinct legacy_type
+                # rows in v2 for collision preservation
+                v2_legacy = passed_for_legacy
+            else:
+                # normal write-door dedupes even for synonym labels (legacy_type='')
+                v2_legacy = ""
+        # v2 may use distinct eid when preserving legacy collisions (different from
+        # the canon-based edge_id used for legacy edges table which always dedupes)
+        v2_eid = (
+            f"edge:{_sha256_text(f'{from_node}|{edge_type}|{to_node}|{v2_legacy}')[:24]}"
+            if v2_legacy
+            else edge_id
+        )
         self._v2_project_edge(
             conn,
             from_node,
@@ -94,9 +120,10 @@ class KnowledgeGraphWriteMixin:
             edge_type,
             float(weight),
             meta_json,
-            edge_id=edge_id,
+            edge_id=v2_eid,
             created_at=now,
             strict=True,
+            legacy_type=v2_legacy,
         )
         conn.execute(
             """

package/lattice_brain/runtime/__init__.py

@@ -44,9 +44,9 @@ orchestrator, and the agent runtime service. Lazy-loaded so importing
     /agents/api/runtime/* , POST /agents (start via runtime.start or executor)
   api/chat.py
     from latticeai.services.tool_dispatch import build_agent_runtime
-    -> latticeai/core/agent.py:AgentRuntime (별도 state/plan/transcript 머신, single-agent /agent 경로. dispatch_tool 만 공유)
+    -> latticeai/core/agent.py:SingleAgentRuntime (별도 state/plan/transcript 머신, single-agent /agent 경로. dispatch_tool 만 공유)
   latticeai/services/tool_dispatch.py:14
-    from latticeai.core.agent import AgentRuntime as CoreAgentRuntime
+    from latticeai.core.agent import SingleAgentRuntime
     (tool governance + core single-agent용)
   latticeai/services/platform_runtime.py
     from lattice_brain.runtime.{hooks, multi_agent}
@@ -54,6 +54,7 @@ orchestrator, and the agent runtime service. Lazy-loaded so importing
 
 core/tool_registry.py (신규) + services/tool_dispatch.py 가 tool build 주도.
 lattice_brain/runtime 는 multi-agent + hooks + facade 에 집중. core/agent 는 chat/agent 단일 루프.
+기존 latticeai.core.agent.AgentRuntime import 는 SingleAgentRuntime 호환 alias 로 유지.
 
 이 매핑으로 중복 제거 및 wiring 명확화 완료 (feat(Act, automation) 방향).
 """
@@ -64,6 +65,7 @@ __all__ = [
     "AgentRuntime",
     "AgentRuntimeUnavailable",
     "MultiAgentOrchestrator",
+    "RuntimeBoundaryProtocol",
     "HooksRegistry",
     "dispatch_tool",
 ]
@@ -78,6 +80,10 @@ def __getattr__(name: str):
         from .multi_agent import MultiAgentOrchestrator
 
         return MultiAgentOrchestrator
+    if name == "RuntimeBoundaryProtocol":
+        from .contracts import RuntimeBoundaryProtocol
+
+        return RuntimeBoundaryProtocol
     if name in {"HooksRegistry", "dispatch_tool"}:
         from . import hooks
 

package/lattice_brain/runtime/agent_runtime.py

@@ -37,7 +37,13 @@ from .multi_agent import (
     MULTI_AGENT_VERSION,
     ROLE_AGENT_IDS,
 )
-from .contracts import contract_view, contract_views, extract_contract, multi_agent_contract
+from .contracts import (
+    contract_view,
+    contract_views,
+    extract_contract,
+    multi_agent_contract,
+    runtime_boundary_contract,
+)
 
 ROLE_DESCRIPTIONS = {
     "researcher": "Gathers workspace context and memory for the goal.",
@@ -91,10 +97,20 @@ class AgentRuntime:
     def _execution_mode(self) -> str:
         return "async" if self._run_executor is not None else "synchronous"
 
+    def boundary(self) -> Dict[str, Any]:
+        return runtime_boundary_contract(
+            name="AgentRuntime",
+            runtime="multi_agent",
+            entrypoint="lattice_brain.runtime.agent_runtime.AgentRuntime",
+            surface="/agents",
+            owns="product agent execution, observability, status, health, events, replay, and stop",
+        )
+
     # ── configuration ─────────────────────────────────────────────────────
     def config(self) -> Dict[str, Any]:
         return {
             "version": MULTI_AGENT_VERSION,
+            "boundary": self.boundary(),
             "roles": list(AGENT_ROLES),
             "default_pipeline": list(CORE_PIPELINE),
             "max_retries_cap": self._max_retries_cap,

package/lattice_brain/runtime/contracts.py

@@ -30,7 +30,7 @@ from __future__ import annotations
 
 from dataclasses import dataclass, field
 from datetime import datetime
-from typing import Any, Dict, Iterable, List, Optional
+from typing import Any, Dict, Iterable, List, Optional, Protocol, runtime_checkable
 
 
 def runtime_timestamp() -> str:
@@ -69,6 +69,8 @@ CONTRACT_VIEW_KEYS = (
     "blocking_reasons",
 )
 
+RUNTIME_BOUNDARY_SCHEMA = "runtime-boundary/v1"
+
 _SCHEMA_FOR_KIND = {
     "agent_run": AGENT_RUN_SCHEMA,
     "workflow_run": WORKFLOW_RUN_SCHEMA,
@@ -223,6 +225,67 @@ def multi_agent_contract(
     ).as_dict()
 
 
+@dataclass(frozen=True)
+class RuntimeBoundaryContract:
+    """Machine-readable descriptor for an execution runtime boundary.
+
+    This is intentionally separate from run records: it lets tests, routers, and
+    docs assert which class owns which execution surface without importing the
+    wrong runtime by name.
+    """
+
+    name: str
+    runtime: str
+    entrypoint: str
+    surface: str
+    owns: str
+    compatibility_aliases: List[str] = field(default_factory=list)
+
+    def as_dict(self) -> Dict[str, Any]:
+        return {
+            "schema_version": RUNTIME_BOUNDARY_SCHEMA,
+            "name": self.name,
+            "runtime": self.runtime,
+            "entrypoint": self.entrypoint,
+            "surface": self.surface,
+            "owns": self.owns,
+            "compatibility_aliases": list(self.compatibility_aliases),
+        }
+
+
+def runtime_boundary_contract(
+    *,
+    name: str,
+    runtime: str,
+    entrypoint: str,
+    surface: str,
+    owns: str,
+    compatibility_aliases: Optional[List[str]] = None,
+) -> Dict[str, Any]:
+    return RuntimeBoundaryContract(
+        name=name,
+        runtime=runtime,
+        entrypoint=entrypoint,
+        surface=surface,
+        owns=owns,
+        compatibility_aliases=list(compatibility_aliases or []),
+    ).as_dict()
+
+
+@runtime_checkable
+class RuntimeBoundaryProtocol(Protocol):
+    """Minimal shared surface for runtime boundary discovery.
+
+    Product ``AgentRuntime`` and core ``SingleAgentRuntime`` intentionally keep
+    different execution methods. This protocol only fixes the common inspection
+    surface that DI, readiness gates, and tests can depend on safely.
+    """
+
+    def boundary(self) -> Dict[str, Any]: ...
+
+    def config(self) -> Dict[str, Any]: ...
+
+
 def run_record_contract(run: Dict[str, Any], *, runtime: str = "multi_agent") -> Dict[str, Any]:
     """Build the family contract from a persisted agent run row."""
     run = dict(run or {})

package/lattice_brain/runtime/multi_agent.py

@@ -21,7 +21,7 @@ from typing import Any, Callable, Dict, List, Optional
 from .contracts import multi_agent_contract
 
 
-MULTI_AGENT_VERSION = "7.8.0"
+MULTI_AGENT_VERSION = "8.0.0"
 
 AGENT_ROLES = ("researcher", "planner", "executor", "reviewer", "release")
 CORE_PIPELINE = ("planner", "executor", "reviewer")

package/latticeai/__init__.py

@@ -1,3 +1,3 @@
 """Lattice AI - modular server package."""
 
-__version__ = "7.8.0"
+__version__ = "8.0.0"

package/latticeai/core/agent.py

@@ -1,7 +1,7 @@
-"""Agent Runtime — the Discover→Plan→Implement→Verify state machine.
+"""Single-agent runtime — the Discover→Plan→Implement→Verify state machine.
 
-This module is the deep one: a small interface (``AgentDeps`` ports +
-``AgentRuntime.run_to_completion``) over the whole multi-role agent loop
+This module is the deep single-agent loop: a small interface (``AgentDeps`` ports +
+``SingleAgentRuntime.run_to_completion``) over the whole role-phased state machine
 (planner → executor → critic → rollback → memory). It carries no FastAPI,
 no globals, and no I/O of its own — every collaborator is injected through
 ``AgentDeps``.
@@ -23,14 +23,13 @@ from __future__ import annotations
 import json
 import logging
 import re
-import subprocess
 from dataclasses import dataclass
 from enum import Enum
 from pathlib import Path
 from typing import Any, Awaitable, Callable, Dict, FrozenSet, List, Optional
 
 from lattice_brain.runtime.hooks import dispatch_tool
-from lattice_brain.runtime.contracts import single_agent_contract
+from lattice_brain.runtime.contracts import runtime_boundary_contract, single_agent_contract
 from tools import ToolError
 
 
@@ -92,7 +91,7 @@ def extract_action(raw: str) -> Dict:
 
 @dataclass
 class AgentDeps:
-    """The ports an :class:`AgentRuntime` needs from the outside world.
+    """The ports a :class:`SingleAgentRuntime` needs from the outside world.
 
     Everything the state machine touches is here, so the loop can be exercised
     against fakes. See module docstring for the two-adapter rationale.
@@ -125,6 +124,11 @@ class AgentDeps:
     memory_updater_prompt: str
     agent_root: Path
 
+    # ── rollback port (optional) ─────────────────────────────────────
+    # Production injects this from the tool dispatch service so this pure
+    # state machine does not shell out directly. Tests can pass a recorder.
+    rollback_file: Optional[Callable[[str], Dict[str, Any]]] = None
+
     # ── lifecycle hooks port (optional) ──────────────────────────────
     # When present, every tool execution fires the shared pre_tool/post_tool
     # lifecycle, so the agent tool path no longer bypasses hooks.
@@ -137,12 +141,30 @@ class AgentDeps:
     brain_memory: Any = None
 
 
-class AgentRuntime:
+class SingleAgentRuntime:
     """Drives the agent state machine over injected :class:`AgentDeps`."""
 
     def __init__(self, deps: AgentDeps) -> None:
         self.deps = deps
 
+    def boundary(self) -> Dict[str, Any]:
+        return runtime_boundary_contract(
+            name="SingleAgentRuntime",
+            runtime="single_agent",
+            entrypoint="latticeai.core.agent.SingleAgentRuntime",
+            surface="/agent",
+            owns="single-agent PLAN / EXECUTE / VERIFY state machine over injected ports",
+            compatibility_aliases=["latticeai.core.agent.AgentRuntime"],
+        )
+
+    def config(self) -> Dict[str, Any]:
+        return {
+            "boundary": self.boundary(),
+            "states": [state.value for state in AgentState],
+            "terminal_states": sorted(state.value for state in AGENT_TERMINAL_STATES),
+            "execution_mode": "injected_ports",
+        }
+
     def contract(self, ctx: AgentRunContext, req: Any, *, run_id: Optional[str] = None) -> Dict[str, Any]:
         """Expose the shared agent-run contract for the single-agent loop."""
         return single_agent_contract(ctx=ctx, goal=getattr(req, "message", ""), run_id=run_id)
@@ -405,12 +427,11 @@ class AgentRuntime:
             path = result.get("path") or (step.get("args") or {}).get("path", "")
             if not path:
                 continue
+            if d.rollback_file is None:
+                rolled.append({"path": path, "ok": False, "error": "rollback_file port is not configured"})
+                continue
             try:
-                r = subprocess.run(
-                    ["git", "checkout", "--", path], cwd=str(d.agent_root),
-                    capture_output=True, text=True, timeout=10,
-                )
-                rolled.append({"path": path, "ok": r.returncode == 0, "stderr": r.stderr[:200]})
+                rolled.append(d.rollback_file(str(path)))
             except Exception as exc:
                 rolled.append({"path": path, "ok": False, "error": str(exc)})
 
@@ -491,3 +512,9 @@ class AgentRuntime:
                 ctx.state = AgentState.FAILED
 
         ctx.state_history.append(ctx.state.value)
+
+
+# Backward compatibility: external callers historically imported
+# ``latticeai.core.agent.AgentRuntime`` for the single-agent state machine.
+# The product/runtime facade lives at ``lattice_brain.runtime.agent_runtime``.
+AgentRuntime = SingleAgentRuntime

package/latticeai/core/marketplace.py

@@ -11,7 +11,7 @@ from copy import deepcopy
 from typing import Any, Dict, List, Optional
 
 
-MARKETPLACE_VERSION = "7.8.0"
+MARKETPLACE_VERSION = "8.0.0"
 TEMPLATE_KINDS = ("plugin", "workflow", "agent")
 
 

package/latticeai/core/tool_registry.py

@@ -292,7 +292,14 @@ class ToolRegistry:
             })
         diagnostics = self.diagnostics()
         return {
+            "schema_version": "tool-registry-contract/v1",
             "status": "ok" if diagnostics["ready"] else "degraded",
+            "boundary": {
+                "owner": "latticeai.core.tool_registry.ToolRegistry",
+                "dispatch_owner": "tools.DEFAULT_TOOL_REGISTRY",
+                "policy_owner": "latticeai.core.tool_registry.ToolRegistry",
+                "permission_owner": "latticeai.services.tool_dispatch.ToolDispatchService",
+            },
             "catalog_brief": self.catalog_brief.strip(),
             "diagnostics": diagnostics,
             "tools": tools,

package/latticeai/core/workspace_os.py

@@ -21,7 +21,7 @@ from typing import Any, Callable, Dict, Iterable, List, Optional
 from lattice_brain.runtime.contracts import realtime_event_contract, run_record_contract, workflow_run_contract
 
 
-WORKSPACE_OS_VERSION = "7.8.0"
+WORKSPACE_OS_VERSION = "8.0.0"
 
 # Workspace types separate single-user Personal workspaces from shared
 # Organization workspaces. Both keep the same local-first JSON store; the type

package/latticeai/services/architecture_readiness.py

@@ -1,10 +1,9 @@
 """Machine-checkable architecture readiness gates for release work.
 
-The 7.7 complete-product line preserves the 7.6 closure of the two local review
-notes by keeping their architectural claims in a small contract: AgentRuntime,
-ToolRegistry, central Config,
-decomposed API routers, and Knowledge Graph portability must all be discoverable
-and testable before the release can be called complete.
+8.0.0 turns the major architecture priorities into an explicit release
+contract. AgentRuntime, ToolRegistry, central Config, decomposed server runtime,
+and Knowledge Graph stabilization must be discoverable, ordered, and backed by
+tests before the release can be called complete.
 """
 
 from __future__ import annotations
@@ -15,6 +14,19 @@ from pathlib import Path
 from typing import Any, Dict, List
 
 
+ARCHITECTURE_VERSION_TARGET = "8.0.0"
+
+PREFERRED_REFACTORING_ORDER = [
+    "agent-runtime",
+    "tool-registry",
+    "config-centralization",
+    "server-decomposition",
+    "kg-hardening",
+    "documentation-sync",
+    "ui-enhancements",
+]
+
+
 @dataclass(frozen=True)
 class ArchitectureGate:
     id: str
@@ -108,12 +120,43 @@ def architecture_readiness(root: Path | None = None) -> Dict[str, Any]:
 
     api_router_count = len(list((root / "latticeai" / "api").glob("*.py")))
     runtime_module_count = len(list((root / "latticeai" / "runtime").glob("*.py")))
+    ordered_gate_ids = [gate.id for gate in gates]
+    contract = {
+        "schema_version": "lattice-architecture-contract/v1",
+        "version_target": ARCHITECTURE_VERSION_TARGET,
+        "refactoring_order": list(PREFERRED_REFACTORING_ORDER),
+        "boundaries": {
+            "agent-runtime": {
+                "owner": "lattice_brain.runtime.agent_runtime.AgentRuntime",
+                "surface": "/agents",
+                "status": "facade",
+            },
+            "tool-registry": {
+                "owner": "latticeai.core.tool_registry.ToolRegistry",
+                "surface": "/tools",
+                "status": "registry",
+            },
+            "config-centralization": {
+                "owner": "latticeai.core.config.Config",
+                "surface": "composition root",
+                "status": "typed-config",
+            },
+            "kg-hardening": {
+                "owner": "lattice_brain.graph.store.KnowledgeGraphStore",
+                "strategy": "additive reprojection with legacy read compatibility",
+                "rollback": "portable export/import and non-destructive migration paths",
+            },
+        },
+        "ordered_gate_ids": ordered_gate_ids,
+    }
     return {
         "status": "complete" if all(gate.status == "complete" for gate in gates) else "incomplete",
-        "version_target": "7.8.0",
+        "version_target": ARCHITECTURE_VERSION_TARGET,
+        "contract": contract,
         "gates": [gate.__dict__ for gate in gates],
         "metrics": {
             "api_router_modules": api_router_count,
             "runtime_modules": runtime_module_count,
+            "architecture_gates": len(gates),
         },
     }

package/latticeai/services/product_readiness.py

@@ -1,12 +1,13 @@
-"""Machine-checkable *product* readiness gates for the 7.8 line.
+"""Machine-checkable *product* readiness gates for the 8.0 line.
 
 Where ``architecture_readiness`` proves the internal structure is sound, this
-module answers the product question the 7.8 release exists to settle: *can
-someone understand and use the Brain at a glance?* It does so honestly — every
-gate is backed by evidence that is probed on disk, so a gate only reports
-``complete`` when its evidence actually resolves. The same report can be printed
-by ``scripts/product_readiness.py`` and re-run after every change, which is the
-point: completeness is something we keep measuring, not a one-time claim.
+module answers the product question the 8.0 release exists to settle: *are the
+runtime boundaries still clear and release-ready after hardening?* It does so
+honestly — every gate is backed by evidence that is probed on disk, so a gate
+only reports ``complete`` when its evidence actually resolves. The same report
+can be printed by ``scripts/product_readiness.py`` and re-run after every
+change, which is the point: completeness is something we keep measuring, not a
+one-time claim.
 """
 
 from __future__ import annotations
@@ -17,7 +18,7 @@ from typing import Any, Dict, List
 
 from latticeai.services.architecture_readiness import architecture_readiness
 
-PRODUCT_VERSION_TARGET = "7.8.0"
+PRODUCT_VERSION_TARGET = "8.0.0"
 
 
 @dataclass(frozen=True)
@@ -64,10 +65,10 @@ PRODUCT_GATES: List[ProductGate] = [
         evidence=[
             "package.json::release:artifacts",
             "package.json::release:validate",
-            "README.md::dist/ltcai-7.8.0-py3-none-any.whl",
-            "README.md::dist/ltcai-7.8.0.tar.gz",
-            "README.md::dist/ltcai-7.8.0.vsix",
-            "README.md::ltcai-7.8.0.tgz",
+            "README.md::dist/ltcai-8.0.0-py3-none-any.whl",
+            "README.md::dist/ltcai-8.0.0.tar.gz",
+            "README.md::dist/ltcai-8.0.0.vsix",
+            "README.md::ltcai-8.0.0.tgz",
             "scripts/validate_release_artifacts.py",
             "scripts/release_smoke.py",
             "Dockerfile",
@@ -83,12 +84,20 @@ PRODUCT_GATES: List[ProductGate] = [
         title="Release story is documented and honest",
         evidence=[
             "README.md",
-            "README.md::The current release is **7.8.0",
-            "SECURITY.md::7.8.x (latest)",
-            "vscode-extension/README.md::**7.8.0",
-            "docs/CHANGELOG.md::## [7.8.0]",
+            "README.md::The current release is **8.0.0",
+            "SECURITY.md::8.0.x (latest)",
+            "vscode-extension/README.md::**8.0.0",
+            "docs/CHANGELOG.md::## [8.0.0]",
             "FEATURE_STATUS.md",
-            "RELEASE_NOTES_v7.8.0.md",
+            "RELEASE_NOTES_v8.0.0.md",
+            "latticeai/core/agent.py::SingleAgentRuntime",
+            "latticeai/core/agent.py::AgentRuntime = SingleAgentRuntime",
+            "lattice_brain/runtime/contracts.py::runtime-boundary/v1",
+            "lattice_brain/runtime/contracts.py::RuntimeBoundaryProtocol",
+            "lattice_brain/runtime/agent_runtime.py::def boundary",
+            "latticeai/core/agent.py::def boundary",
+            "latticeai/services/architecture_readiness.py::lattice-architecture-contract/v1",
+            "latticeai/services/tool_dispatch.py::rollback_file",
         ],
     ),
     ProductGate(

package/latticeai/services/tool_dispatch.py

@@ -8,11 +8,12 @@ from __future__ import annotations
 
 from dataclasses import dataclass, field
 from pathlib import Path
+import subprocess
 from typing import Any, Callable, Dict, Mapping, Optional
 
 from fastapi import HTTPException
 
-from latticeai.core.agent import AgentDeps, AgentRuntime
+from latticeai.core.agent import AgentDeps, SingleAgentRuntime
 from latticeai.core.agent_prompts import (
     CRITIC_PROMPT,
     EXECUTOR_PROMPT,
@@ -106,6 +107,16 @@ class ToolDispatchService:
                 detail=f"'{tool_name}' 툴은 관리자 전용입니다.",
             )
 
+    def rollback_file(self, path: str) -> Dict[str, Any]:
+        r = subprocess.run(
+            ["git", "checkout", "--", path],
+            cwd=str(AGENT_ROOT),
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+        return {"path": path, "ok": r.returncode == 0, "stderr": r.stderr[:200]}
+
 
 DEFAULT_TOOL_DISPATCH_SERVICE = ToolDispatchService()
 
@@ -185,7 +196,7 @@ def build_agent_runtime(
     hooks: Any = None,
     brain_memory: Any = None,
     dispatch_service: ToolDispatchService = DEFAULT_TOOL_DISPATCH_SERVICE,
-) -> AgentRuntime:
+) -> SingleAgentRuntime:
     ensure_agent_root()
     deps = AgentDeps(
         generate_as=model_router.generate_as,
@@ -205,10 +216,11 @@ def build_agent_runtime(
         critic_prompt=CRITIC_PROMPT,
         memory_updater_prompt=MEMORY_UPDATER_PROMPT,
         agent_root=AGENT_ROOT,
+        rollback_file=dispatch_service.rollback_file,
         hooks=hooks,
         brain_memory=brain_memory,
     )
-    return AgentRuntime(deps)
+    return SingleAgentRuntime(deps)
 
 
 def tool_response(fn, *args):

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ltcai",
-  "version": "7.8.0",
+  "version": "8.0.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/src-tauri/Cargo.lock

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

package/src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "lattice-ai-desktop"
-version = "7.8.0"
+version = "8.0.0"
 description = "Lattice AI Digital Brain desktop shell"
 authors = ["TaeSoo Park"]
 edition = "2021"

package/src-tauri/tauri.conf.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://schema.tauri.app/config/2",
   "productName": "Lattice AI",
-  "version": "7.8.0",
+  "version": "8.0.0",
   "identifier": "ai.lattice.desktop",
   "build": {
     "beforeDevCommand": "npm run frontend:dev",

package/static/app/asset-manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "7.8.0",
+  "version": "8.0.0",
   "generated_at": "vite",
   "entrypoints": {
     "app": "/static/app/index.html"