ltcai 7.9.0 → 8.0.0

package/README.md

@@ -1,6 +1,6 @@
 # Lattice AI
 
-**Lattice AI 7.9 is the local-first Digital Brain product with cleaner runtime boundaries. It keeps your knowledge durable across any AI model, with Brain Chat Home ready for immediate use and agent execution hardened behind explicit runtime ports.**
+**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 clearer 7.9 agent-runtime boundary.
+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.9 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.
 
@@ -210,36 +210,39 @@ See [docs/DEVELOPMENT.md](docs/DEVELOPMENT.md) for developer workflow details.
 
 ## Current Release
 
-The current release is **7.9.0 — Agent Runtime Boundary Hardening**:
+The current release is **8.0.0 — Runtime Architecture Contract**:
 
-- The single-agent state machine is now named `SingleAgentRuntime`, while the
-  historical `AgentRuntime` import remains as a compatibility alias.
+- `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.
-- Agent rollback is now an injected runtime port wired through
-  `ToolDispatchService`, so the core state machine no longer shells out directly.
-- Both runtime surfaces expose a `runtime-boundary/v1` descriptor so tests and
-  API clients can identify the owning execution boundary without relying on
-  ambiguous class names.
-- A shared `RuntimeBoundaryProtocol` now fixes the common inspection surface
-  while letting each runtime keep its own execution methods.
+- 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.9 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.9.0 release must use exact filenames:
+Expected artifacts for 8.0.0 release must use exact filenames:
 
-- `dist/ltcai-7.9.0-py3-none-any.whl`
-- `dist/ltcai-7.9.0.tar.gz`
-- `ltcai-7.9.0.tgz`
-- `dist/ltcai-7.9.0.vsix`
-- `src-tauri/target/release/bundle/dmg/Lattice AI_7.9.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 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.9.0 and the follow-up tracks.
+strategic roadmap slices applied through 8.0.0 and the follow-up tracks.
 
 ## Known Limitations
 
@@ -256,6 +259,7 @@ strategic roadmap slices applied through 7.9.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 |

package/docs/CHANGELOG.md

@@ -6,6 +6,27 @@ 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

package/lattice_brain/__init__.py

@@ -26,7 +26,7 @@ from .storage import (
     storage_from_env,
 )
 
-__version__ = "7.9.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/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.9.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.9.0"
+__version__ = "8.0.0"

package/latticeai/core/marketplace.py

@@ -11,7 +11,7 @@ from copy import deepcopy
 from typing import Any, Dict, List, Optional
 
 
-MARKETPLACE_VERSION = "7.9.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.9.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.9.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.9 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.9 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.
+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.9.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.9.0-py3-none-any.whl",
-            "README.md::dist/ltcai-7.9.0.tar.gz",
-            "README.md::dist/ltcai-7.9.0.vsix",
-            "README.md::ltcai-7.9.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,18 +84,19 @@ PRODUCT_GATES: List[ProductGate] = [
         title="Release story is documented and honest",
         evidence=[
             "README.md",
-            "README.md::The current release is **7.9.0",
-            "SECURITY.md::7.9.x (latest)",
-            "vscode-extension/README.md::**7.9.0",
-            "docs/CHANGELOG.md::## [7.9.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.9.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",
         ],
     ),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ltcai",
-  "version": "7.9.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.9.0"
+version = "8.0.0"
 dependencies = [
  "plist",
  "serde",

package/src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "lattice-ai-desktop"
-version = "7.9.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.9.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.9.0",
+  "version": "8.0.0",
   "generated_at": "vite",
   "entrypoints": {
     "app": "/static/app/index.html"