ltcai 7.1.0 → 7.2.0

package/README.md

@@ -200,25 +200,26 @@ See [docs/DEVELOPMENT.md](docs/DEVELOPMENT.md) for developer workflow details.
 
 ## Current Release
 
-The current release is **7.1.0 Brain Usability Completion**:
-
-- First-run onboarding now explains detected hardware, recommendation timing,
-  install progress, and the next action in plain language.
-- Brain Home shows ingestion progress for files, folders, notes, and web pages,
-  including memory emergence after content lands.
-- Knowledge Graph exploration adds search suggestions, type filters, time
-  exploration, focus movement, and neighbor highlighting.
-- Chat answers surface inline source citations and accessible proof payloads.
-- Workspace/profile/admin entry points, empty/error feedback, consent revoke
-  feedback, and VS Code extension sync status are visible in the product shell.
-
-Expected artifacts for 7.1.0 release must use exact filenames:
-
-- `dist/ltcai-7.1.0-py3-none-any.whl`
-- `dist/ltcai-7.1.0.tar.gz`
-- `ltcai-7.1.0.tgz`
-- `dist/ltcai-7.1.0.vsix`
-- `src-tauri/target/release/bundle/dmg/Lattice AI_7.1.0_aarch64.dmg`
+The current release is **7.2.0 Runtime Trust Baseline**:
+
+- Agent runs can be previewed before execution, including selected roles,
+  clamped retry budget, readiness state, and blocking reasons.
+- Product agent execution refuses simulation-mode success unless simulation is
+  explicitly enabled for a non-product runtime.
+- ToolRegistry exposes a live manifest and diagnostics endpoint covering
+  dispatch handlers, governance policy, catalog descriptions, and permissions.
+- Tool governance/catalog drift is covered by unit tests so tool additions
+  cannot silently bypass policy or disappear from operator views.
+- 7.1.0 Brain usability work remains intact while the runtime gains clearer
+  contracts for admin surfaces and future AgentRuntime extraction.
+
+Expected artifacts for 7.2.0 release must use exact filenames:
+
+- `dist/ltcai-7.2.0-py3-none-any.whl`
+- `dist/ltcai-7.2.0.tar.gz`
+- `ltcai-7.2.0.tgz`
+- `dist/ltcai-7.2.0.vsix`
+- `src-tauri/target/release/bundle/dmg/Lattice AI_7.2.0_aarch64.dmg`
 
 Do not upload `dist/*`. Package registry publishing remains owner-run.
 
@@ -237,6 +238,7 @@ Do not upload `dist/*`. Package registry publishing remains owner-run.
 
 | Version | Theme |
 | --- | --- |
+| 7.2.0 | Runtime Trust Baseline: agent run preview/readiness, simulation-mode guardrails, live ToolRegistry manifest/diagnostics, and tests for dispatch/governance/catalog drift |
 | 7.1.0 | Brain Usability Completion: clearer first-run onboarding, ingestion progress/emergence, richer graph controls, inline answer proof, workspace/profile/admin discovery, empty/error/consent feedback, and VS Code sync status |
 | 7.0.0 | Brain Productization Loop: first-screen ingestion for files/folders/notes/web, answer-level memory proof and source citations, model-continuity demo flow, five-minute first-run loop, and recall/KG quality eval in CI |
 | 6.7.0 | Brain IA Cleanup: reachable rich pages, separated product routes vs compatibility aliases, shared Brain shell navigation, and lazy-loaded rich pages |

package/docs/CHANGELOG.md

@@ -4,6 +4,26 @@ The top entry is either the current unreleased main-branch work or the current
 release line. Older entries are historical and may describe behavior as it
 existed at that release.
 
+## [7.2.0] - 2026-06-20
+
+> Runtime Trust Baseline. Adds execution preview and registry diagnostics so
+> agent runs and tool permissions become inspectable contracts before action.
+
+### Added
+- `POST /agents/api/run/preview` for AgentRuntime readiness, role selection,
+  input keys, retry clamping, and blocking reasons without starting a run.
+- `GET /tools/registry` for the live ToolRegistry manifest across dispatch
+  handlers, governance policy, catalog descriptions, and permissions.
+- `GET /tools/registry/diagnostics` for a compact drift check suitable for CI,
+  admin views, and runtime health panels.
+- Unit coverage for AgentRuntime preview and ToolRegistry manifest diagnostics.
+
+### Changed
+- Tool governance now covers `read_document`, and the catalog describes
+  `create_web_project`, closing the current dispatch/governance/catalog drift.
+- Package/runtime/static metadata is synchronized to 7.2.0; package publish and
+  deployment remain owner-run only.
+
 ## [7.1.0] - 2026-06-20
 
 > Brain Usability Completion. Completes the 7.1.0 first-run through editor-sync

package/frontend/src/api/client.ts

@@ -481,7 +481,10 @@ export const latticeApi = {
   unloadModel: (model_id: string) => del(`/models/unload/${encodeURIComponent(model_id)}`, {}),
   embeddingsStatus: () => get("/api/embeddings/status", {}),
   agentRuntime: () => get("/agents/api/runtime/status", { runtime: {}, agents: [], runs: [] }),
+  agentRunPreview: (goal: string, roles: string[] = []) => post("/agents/api/run/preview", { goal, roles }, { ready: false, blocking_reasons: [] }),
   runAgent: (goal: string, roles: string[]) => post("/agents/api/run", { goal, roles }, {}),
+  toolRegistryDiagnostics: () => get("/tools/registry/diagnostics", { diagnostics: { ready: false } }),
+  toolRegistry: () => get("/tools/registry", { status: "unavailable", diagnostics: {}, tools: [] }),
   agentRun: (id: string) => get(`/agents/api/runs/${encodeURIComponent(id)}`, {}),
   stopAgentRun: (id: string) => post(`/agents/api/runs/${encodeURIComponent(id)}/stop`, {}, {}),
   agentRegistry: () => get("/agents/api/registry", { agents: [] }),

package/frontend/src/features/admin/AdminConsole.tsx

@@ -15,7 +15,7 @@ export function AdminConsole({ onBack }: { onBack: () => void }) {
   const qc = useQueryClient();
   const language = useAppStore((state) => state.language);
   const [filters, setFilters] = React.useState<AdminFilterState>({ q: "", actor: "", action: "", severity: "", limit: 50 });
-  const { summaryQ, statsQ, usersQ, auditQ, securityQ, securityEventsQ, policiesQ, rolesQ, retentionQ, indexQ } = useAdminConsoleData(filters);
+  const { summaryQ, statsQ, usersQ, auditQ, securityQ, securityEventsQ, policiesQ, rolesQ, retentionQ, indexQ, agentRuntimeQ, toolRegistryQ } = useAdminConsoleData(filters);
   const rebuildIndex = useMutation({
     mutationFn: latticeApi.rebuildIndex,
     onSuccess: () => void qc.invalidateQueries({ queryKey: ["indexStatus"] }),
@@ -139,6 +139,10 @@ export function AdminConsole({ onBack }: { onBack: () => void }) {
           </div>
         </AdminPanel>
 
+        <AdminPanel title={t(language, "admin.panel.runtimeTrust")} eyebrow={t(language, "admin.panel.contracts")}>
+          <RuntimeTrustPanel runtime={agentRuntimeQ.data?.data as ApiRecord | undefined} registry={toolRegistryQ.data?.data as ApiRecord | undefined} language={language} />
+        </AdminPanel>
+
       </section>
     </main>
   );
@@ -164,9 +168,45 @@ function useAdminConsoleData(filters: AdminFilterState) {
     rolesQ: useQuery({ queryKey: ["adminRoles"], queryFn: latticeApi.adminRoles }),
     retentionQ: useQuery({ queryKey: ["adminLogRetention"], queryFn: latticeApi.adminLogRetention }),
     indexQ: useQuery({ queryKey: ["indexStatus"], queryFn: latticeApi.indexStatus }),
+    agentRuntimeQ: useQuery({ queryKey: ["agentRuntime"], queryFn: latticeApi.agentRuntime }),
+    toolRegistryQ: useQuery({ queryKey: ["toolRegistryDiagnostics"], queryFn: latticeApi.toolRegistryDiagnostics }),
   };
 }
 
+function RuntimeTrustPanel({ runtime, registry, language }: { runtime?: ApiRecord; registry?: ApiRecord; language: "ko" | "en" }) {
+  const runtimeInfo = (runtime?.runtime || {}) as ApiRecord;
+  const health = (runtime?.health || {}) as ApiRecord;
+  const diagnostics = (registry?.diagnostics || {}) as ApiRecord;
+  const ready = Boolean(runtimeInfo.ready);
+  const registryReady = Boolean(diagnostics.ready);
+  const blocking = stringValue(runtimeInfo.unavailable_reason, ready ? t(language, "admin.runtime.readyDetail") : t(language, "admin.runtime.blockedFallback"));
+  return (
+    <div className="admin-runtime-trust">
+      <div className="admin-runtime-row">
+        <strong>{t(language, "admin.runtime.agent")}</strong>
+        <span className={ready ? "is-ok" : "is-warn"}>{ready ? t(language, "admin.status.ready") : t(language, "admin.status.unavailable")}</span>
+        <small>{blocking}</small>
+      </div>
+      <div className="admin-runtime-row">
+        <strong>{t(language, "admin.runtime.tools")}</strong>
+        <span className={registryReady ? "is-ok" : "is-warn"}>{registryReady ? t(language, "admin.runtime.aligned") : t(language, "admin.runtime.drift")}</span>
+        <small>
+          {t(language, "admin.runtime.toolCounts", {
+            registered: stringValue(diagnostics.registered_tools, "0"),
+            governed: stringValue(diagnostics.governed_tools, "0"),
+            described: stringValue(diagnostics.described_tools, "0"),
+          })}
+        </small>
+      </div>
+      <div className="admin-policy-strip">
+        <span>{t(language, "admin.runtime.mode", { mode: stringValue(runtimeInfo.mode, "unknown") })}</span>
+        <span>{t(language, "admin.runtime.execution", { mode: stringValue(runtimeInfo.execution_mode, "unknown") })}</span>
+        <span>{t(language, "admin.runtime.health", { status: stringValue(health.status, "unknown") })}</span>
+      </div>
+    </div>
+  );
+}
+
 function AdminLogFilters({
   filters,
   matched,

package/frontend/src/i18n.ts

@@ -348,6 +348,8 @@ export const COPY: Record<Language, TextMap> = {
     "admin.panel.protection": "보호",
     "admin.panel.brainOps": "Brain 운영",
     "admin.panel.maintenance": "유지보수",
+    "admin.panel.runtimeTrust": "런타임 신뢰도",
+    "admin.panel.contracts": "계약",
     "admin.empty.users": "관리 API가 보고한 사용자가 없습니다.",
     "admin.empty.roles": "보고된 역할 매트릭스가 없습니다.",
     "admin.empty.audit": "최근 감사 이벤트가 없습니다.",
@@ -369,6 +371,16 @@ export const COPY: Record<Language, TextMap> = {
     "admin.brain.summaryFallback": "로컬 Brain 서비스는 사용자 대화와 분리되어 있습니다.",
     "admin.brain.rebuilding": "재구성 중",
     "admin.brain.rebuild": "인덱스 재구성",
+    "admin.runtime.agent": "AgentRuntime",
+    "admin.runtime.tools": "ToolRegistry",
+    "admin.runtime.readyDetail": "실행 preview와 실제 실행이 준비되었습니다.",
+    "admin.runtime.blockedFallback": "실행 전 preview가 차단 사유를 반환합니다.",
+    "admin.runtime.aligned": "정렬됨",
+    "admin.runtime.drift": "점검 필요",
+    "admin.runtime.toolCounts": "등록 {registered} · 정책 {governed} · 설명 {described}",
+    "admin.runtime.mode": "mode {mode}",
+    "admin.runtime.execution": "exec {mode}",
+    "admin.runtime.health": "health {status}",
     "admin.policy.fallback": "정책",
     "admin.policy.quiet": "정책 API 대기 중",
     "admin.retention.days": "{days}일 보관",
@@ -894,6 +906,8 @@ export const COPY: Record<Language, TextMap> = {
     "admin.panel.protection": "Protection",
     "admin.panel.brainOps": "Brain Operations",
     "admin.panel.maintenance": "Maintenance",
+    "admin.panel.runtimeTrust": "Runtime Trust",
+    "admin.panel.contracts": "Contracts",
     "admin.empty.users": "No users reported by the admin API.",
     "admin.empty.roles": "No role matrix reported.",
     "admin.empty.audit": "No recent audit events.",
@@ -915,6 +929,16 @@ export const COPY: Record<Language, TextMap> = {
     "admin.brain.summaryFallback": "Local Brain services are separated from user chat.",
     "admin.brain.rebuilding": "Rebuilding",
     "admin.brain.rebuild": "Rebuild index",
+    "admin.runtime.agent": "AgentRuntime",
+    "admin.runtime.tools": "ToolRegistry",
+    "admin.runtime.readyDetail": "Run preview and execution are ready.",
+    "admin.runtime.blockedFallback": "Run preview returns the blocking reason before execution.",
+    "admin.runtime.aligned": "Aligned",
+    "admin.runtime.drift": "Needs review",
+    "admin.runtime.toolCounts": "Registered {registered} · governed {governed} · described {described}",
+    "admin.runtime.mode": "mode {mode}",
+    "admin.runtime.execution": "exec {mode}",
+    "admin.runtime.health": "health {status}",
     "admin.policy.fallback": "Policy",
     "admin.policy.quiet": "Policy API quiet",
     "admin.retention.days": "{days} day retention",

package/frontend/src/styles.css

@@ -3472,6 +3472,51 @@ body {
   font-size: 0.88rem;
 }
 
+.admin-runtime-trust {
+  display: grid;
+  gap: 0.72rem;
+}
+
+.admin-runtime-row {
+  display: grid;
+  grid-template-columns: minmax(8rem, 1fr) auto;
+  gap: 0.2rem 0.75rem;
+  border: 1px solid hsl(var(--border) / 0.48);
+  border-radius: 8px;
+  background: hsl(var(--bg) / 0.35);
+  padding: 0.72rem;
+}
+
+.admin-runtime-row strong {
+  color: hsl(var(--fg));
+  font-size: 0.88rem;
+}
+
+.admin-runtime-row > span {
+  align-self: start;
+  border-radius: 999px;
+  padding: 0.18rem 0.48rem;
+  font-size: 0.72rem;
+  font-weight: 700;
+}
+
+.admin-runtime-row > small {
+  grid-column: 1 / -1;
+  color: hsl(var(--fg-muted));
+  font-size: 0.78rem;
+  line-height: 1.35;
+}
+
+.admin-runtime-row .is-ok {
+  background: hsl(151 65% 36% / 0.13);
+  color: hsl(151 48% 32%);
+}
+
+.admin-runtime-row .is-warn {
+  background: hsl(36 88% 52% / 0.14);
+  color: hsl(30 82% 35%);
+}
+
 .brain-document-input,
 .brain-image-input {
   display: inline-flex;

package/lattice_brain/__init__.py

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

package/lattice_brain/runtime/agent_runtime.py

@@ -228,6 +228,57 @@ class AgentRuntime:
             "runs": runs[:25],
         }
 
+    def preview(
+        self,
+        goal: str,
+        *,
+        roles: Optional[List[str]] = None,
+        inputs: Optional[Dict[str, Any]] = None,
+        max_retries: int = 2,
+        scope: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Return the execution contract without reserving or starting a run.
+
+        The preview is the product-facing readiness gate for agent execution:
+        clients can show whether a real LLM-backed run can start, which roles
+        will execute, how retry limits are clamped, and why the run is blocked.
+        """
+
+        requested_roles = list(roles or CORE_PIPELINE)
+        unknown_roles = [role for role in requested_roles if role not in AGENT_ROLES]
+        health = self.health()
+        goal_ready = bool(str(goal or "").strip())
+        retry_budget = max(0, min(int(max_retries or 0), self._max_retries_cap))
+        blocking_reasons: List[str] = []
+        if not goal_ready:
+            blocking_reasons.append("goal is required")
+        if unknown_roles:
+            blocking_reasons.append(f"unknown roles: {', '.join(unknown_roles)}")
+        if not health.get("ready"):
+            orchestrator = (health.get("checks") or {}).get("orchestrator") or {}
+            blocking_reasons.append(str(orchestrator.get("detail") or "agent runtime is unavailable"))
+        can_start = not blocking_reasons
+        return {
+            "ready": can_start,
+            "can_start": can_start,
+            "blocking_reasons": blocking_reasons,
+            "goal": str(goal or "").strip(),
+            "roles": requested_roles,
+            "unknown_roles": unknown_roles,
+            "inputs_keys": sorted((inputs or {}).keys()),
+            "max_retries": retry_budget,
+            "max_retries_requested": max_retries,
+            "scope": scope,
+            "execution_mode": self._execution_mode(),
+            "runtime": {
+                "version": MULTI_AGENT_VERSION,
+                "default_pipeline": list(CORE_PIPELINE),
+                "max_retries_cap": self._max_retries_cap,
+                "simulation_runs_allowed": self._allow_simulation_runs,
+            },
+            "health": health,
+        }
+
     # ── events / state ────────────────────────────────────────────────────
     def list_runs(self, *, scope: Optional[str] = None) -> Dict[str, Any]:
         return self._store.list_agents(workspace_id=scope)

package/lattice_brain/runtime/multi_agent.py

@@ -19,7 +19,7 @@ from datetime import datetime
 from typing import Any, Callable, Dict, List, Optional
 
 
-MULTI_AGENT_VERSION = "7.1.0"
+MULTI_AGENT_VERSION = "7.2.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.1.0"
+__version__ = "7.2.0"

package/latticeai/api/agents.py

@@ -192,4 +192,16 @@ def create_agents_router(
             # A pre_run hook gated this run (e.g. a policy/permission hook).
             raise HTTPException(status_code=403, detail=str(exc)) from exc
 
+    @router.post("/agents/api/run/preview")
+    async def agent_run_preview(req: AgentRunRequest, request: Request):
+        require_user(request)
+        scope = gate_read(request)
+        return runtime.preview(
+            req.goal,
+            scope=scope,
+            roles=req.roles or None,
+            inputs=req.inputs,
+            max_retries=req.max_retries,
+        )
+
     return router

package/latticeai/api/tools.py

@@ -25,6 +25,8 @@ from latticeai.services.tool_dispatch import (
     check_tool_role as _check_tool_role,
     get_tool_permission,
     list_tool_permissions,
+    tool_registry_diagnostics,
+    tool_registry_manifest,
 )
 from latticeai.services.router_context import ToolRouterContext
 from latticeai.services.p_reinforce import BRAIN_DIR
@@ -602,6 +604,18 @@ def create_tools_router(
         """
         require_user(request)
         return {"status": "ok", "permissions": list_tool_permissions()}
+
+    @api_router.get("/tools/registry")
+    async def tools_registry(request: Request):
+        """Full ToolRegistry contract: handlers, governance, catalog, diagnostics."""
+        require_user(request)
+        return tool_registry_manifest()
+
+    @api_router.get("/tools/registry/diagnostics")
+    async def tools_registry_diagnostics(request: Request):
+        """Small drift check for CI/admin runtime readiness views."""
+        require_user(request)
+        return {"status": "ok", "diagnostics": tool_registry_diagnostics()}
     
     
     # ── MCP / skills / plugins router (latticeai.api.mcp, v1.3.0) ────────────────

package/latticeai/core/marketplace.py

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

package/latticeai/core/tool_registry.py

@@ -130,6 +130,7 @@ TOOL_GOVERNANCE: Dict[str, ToolPolicy] = {
     "todo_read": _r(),
     "local_list": _r(sandbox="home"),
     "local_read": _r(sandbox="home"),
+    "read_document": _r(sandbox="home"),
     "git_status": _rs(),
     "git_diff": _rs(),
     "git_log": _rs(),
@@ -189,6 +190,7 @@ MCP_TOOL_DESCRIPTIONS: Dict[str, str] = {
     "clear_history": "Clear chat history to reduce context and speed up responses.",
     "inspect_html": "Inspect local HTML structure and assets.",
     "preview_url": "Return a server URL for a workspace file.",
+    "create_web_project": "Create a web project scaffold inside the workspace.",
     "create_docx": "Create a Word DOCX document in the agent workspace.",
     "create_xlsx": "Create an XLSX spreadsheet in the agent workspace.",
     "create_pptx": "Create a PPTX presentation deck in the agent workspace.",
@@ -251,6 +253,51 @@ class ToolRegistry:
     def registered_tools(self) -> frozenset[str]:
         return frozenset(self.handlers)
 
+    def diagnostics(self) -> Dict[str, Any]:
+        """Return registry drift checks without executing any tool.
+
+        This is intentionally derived from the live registry instance, not from
+        duplicated constants, so admin/runtime surfaces can prove whether the
+        dispatch, governance, and catalog projections are still aligned.
+        """
+
+        registered = set(self.registered_tools())
+        governed = set(self.governance)
+        described = set(self.descriptions)
+        return {
+            "ready": not (governed - registered or registered - governed or registered - described),
+            "registered_tools": len(registered),
+            "governed_tools": len(governed),
+            "described_tools": len(described),
+            "governance_without_handler": sorted(governed - registered),
+            "handler_without_governance": sorted(registered - governed),
+            "handler_without_description": sorted(registered - described),
+            "description_without_handler": sorted(described - registered),
+        }
+
+    def manifest(self) -> Dict[str, Any]:
+        """Serializable tool registry contract for runtime/admin inspection."""
+
+        tools = []
+        for name in sorted(self.registered_tools() | set(self.governance) | set(self.descriptions)):
+            policy = self.policy_for(name, {})
+            tools.append({
+                "name": name,
+                "registered": name in self.handlers,
+                "governed": name in self.governance,
+                "described": name in self.descriptions,
+                "description": self.descriptions.get(name, ""),
+                "policy": dict(policy),
+                "permission": dict(self.permission(name, {})),
+            })
+        diagnostics = self.diagnostics()
+        return {
+            "status": "ok" if diagnostics["ready"] else "degraded",
+            "catalog_brief": self.catalog_brief.strip(),
+            "diagnostics": diagnostics,
+            "tools": tools,
+        }
+
     def execute(self, action: str, args: Dict[str, Any], *, error_cls: type[Exception]) -> Dict[str, Any]:
         handler = self.handlers.get(action)
         if handler is None:

package/latticeai/core/workspace_os.py

@@ -19,7 +19,7 @@ from pathlib import Path
 from typing import Any, Callable, Dict, Iterable, List, Optional
 
 
-WORKSPACE_OS_VERSION = "7.1.0"
+WORKSPACE_OS_VERSION = "7.2.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/tool_dispatch.py

@@ -90,6 +90,12 @@ class ToolDispatchService:
     def permissions(self) -> list[ToolPermission]:
         return self.registry.permissions()
 
+    def diagnostics(self) -> Dict[str, Any]:
+        return self.registry.diagnostics()
+
+    def manifest(self) -> Dict[str, Any]:
+        return self.registry.manifest()
+
     def check_role(self, tool_name: str, current_user: str) -> None:
         if tool_name not in self.registry.admin_only_tools:
             return
@@ -131,6 +137,14 @@ def list_tool_permissions() -> list:
     return DEFAULT_TOOL_DISPATCH_SERVICE.permissions()
 
 
+def tool_registry_diagnostics() -> Dict[str, Any]:
+    return DEFAULT_TOOL_DISPATCH_SERVICE.diagnostics()
+
+
+def tool_registry_manifest() -> Dict[str, Any]:
+    return DEFAULT_TOOL_DISPATCH_SERVICE.manifest()
+
+
 def check_tool_role(tool_name: str, current_user: str) -> None:
     DEFAULT_TOOL_DISPATCH_SERVICE.check_role(tool_name, current_user)
 

package/package.json

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

@@ -1654,7 +1654,7 @@ dependencies = [
 
 [[package]]
 name = "lattice-ai-desktop"
-version = "7.1.0"
+version = "7.2.0"
 dependencies = [
  "plist",
  "serde",

package/src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "lattice-ai-desktop"
-version = "7.1.0"
+version = "7.2.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.1.0",
+  "version": "7.2.0",
   "identifier": "ai.lattice.desktop",
   "build": {
     "beforeDevCommand": "npm run frontend:dev",