ltcai 7.3.0 → 7.5.0

package/lattice_brain/runtime/contracts.py

@@ -4,19 +4,158 @@ These contracts are deliberately small and serializable.  The single-agent
 state machine and the multi-agent facade can evolve independently, but callers
 should see the same run identity, mode, status, role, timeline and artifact
 shape across both paths.
+
+Contract family (7.4.0)
+-----------------------
+Four observability surfaces — agent runs, workflow runs, audit events, and
+realtime events — now share one **contract family**, ``agent-run-contract/v1``.
+Every record emitted by any of these surfaces carries the same envelope keys so
+a single consumer (timeline UI, exporter, replay tooling) can treat them
+uniformly:
+
+* ``family``         — always :data:`CONTRACT_FAMILY` (``agent-run-contract/v1``).
+* ``schema_version`` — the per-surface schema string (see ``*_SCHEMA`` below).
+* ``kind``           — one of :data:`CONTRACT_KINDS`.
+* ``id``             — the record identity (run id / event id), may be ``None``.
+* ``status``         — a normalized lifecycle status string.
+* ``timestamp``      — ISO-8601 second-precision emit/observe time.
+
+Each surface keeps its own rich, surface-specific keys *in addition* to the
+envelope — the envelope is purely additive, so existing consumers are never
+broken.  :func:`stamp_contract` is the single place that writes the envelope;
+:func:`is_contract_member` validates membership for tests and importers.
 """
 
 from __future__ import annotations
 
 from dataclasses import dataclass, field
 from datetime import datetime
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, Iterable, List, Optional
 
 
 def runtime_timestamp() -> str:
     return datetime.now().isoformat(timespec="seconds")
 
 
+# ── Contract family identity ────────────────────────────────────────────────
+# A single family string ties every observability surface together. Per-surface
+# schema versions live *under* the family so each surface can rev independently
+# without forking the family contract consumers depend on.
+CONTRACT_FAMILY = "agent-run-contract/v1"
+
+AGENT_RUN_SCHEMA = "agent-run-contract/v1"
+WORKFLOW_RUN_SCHEMA = "workflow-run-contract/v1"
+AUDIT_EVENT_SCHEMA = "audit-event-contract/v1"
+REALTIME_EVENT_SCHEMA = "realtime-event-contract/v1"
+
+CONTRACT_KINDS = ("agent_run", "workflow_run", "audit_event", "realtime_event")
+
+# The envelope keys every family member is guaranteed to expose.
+CONTRACT_ENVELOPE_KEYS = ("family", "schema_version", "kind", "id", "status", "timestamp")
+CONTRACT_VIEW_KEYS = (
+    "family",
+    "schema_version",
+    "kind",
+    "id",
+    "run_id",
+    "agent_id",
+    "runtime",
+    "mode",
+    "status",
+    "goal",
+    "current_role",
+    "timestamp",
+    "is_terminal",
+    "blocking_reasons",
+)
+
+_SCHEMA_FOR_KIND = {
+    "agent_run": AGENT_RUN_SCHEMA,
+    "workflow_run": WORKFLOW_RUN_SCHEMA,
+    "audit_event": AUDIT_EVENT_SCHEMA,
+    "realtime_event": REALTIME_EVENT_SCHEMA,
+}
+
+
+def stamp_contract(
+    body: Dict[str, Any],
+    *,
+    kind: str,
+    identity: Optional[str],
+    status: str,
+    timestamp: Optional[str] = None,
+) -> Dict[str, Any]:
+    """Return ``body`` with the ``agent-run-contract/v1`` envelope merged in.
+
+    Additive and idempotent: existing keys in ``body`` win for everything except
+    the six envelope keys, which are authoritative. ``kind`` must be one of
+    :data:`CONTRACT_KINDS`; the schema version is derived from it so callers
+    cannot mismatch ``kind`` and ``schema_version``.
+    """
+    if kind not in _SCHEMA_FOR_KIND:
+        raise ValueError(f"unknown contract kind: {kind!r}")
+    enveloped = dict(body)
+    enveloped["family"] = CONTRACT_FAMILY
+    enveloped["schema_version"] = _SCHEMA_FOR_KIND[kind]
+    enveloped["kind"] = kind
+    enveloped["id"] = identity
+    enveloped["status"] = status
+    enveloped["timestamp"] = timestamp or body.get("timestamp") or runtime_timestamp()
+    return enveloped
+
+
+def is_contract_member(record: Any) -> bool:
+    """True if ``record`` carries a valid ``agent-run-contract/v1`` envelope."""
+    if not isinstance(record, dict):
+        return False
+    if record.get("family") != CONTRACT_FAMILY:
+        return False
+    kind = record.get("kind")
+    if kind not in _SCHEMA_FOR_KIND:
+        return False
+    if record.get("schema_version") != _SCHEMA_FOR_KIND[kind]:
+        return False
+    return all(key in record for key in CONTRACT_ENVELOPE_KEYS)
+
+
+def extract_contract(record: Any) -> Optional[Dict[str, Any]]:
+    """Return the normalized family contract carried by ``record``.
+
+    Consumers should call this instead of branching on whether they received an
+    agent run, workflow run, audit row, or realtime event. The function accepts
+    either a raw contract dict or a surface record with a nested ``contract``.
+    """
+    if is_contract_member(record):
+        return dict(record)
+    if isinstance(record, dict) and is_contract_member(record.get("contract")):
+        return dict(record["contract"])
+    return None
+
+
+def require_contract(record: Any) -> Dict[str, Any]:
+    """Return a valid family contract or raise a precise error."""
+    contract = extract_contract(record)
+    if contract is None:
+        raise ValueError("record is missing an agent-run-contract/v1 family contract")
+    return contract
+
+
+def contract_view(record: Any) -> Dict[str, Any]:
+    """Return a compact, surface-agnostic view for API and UI consumers."""
+    contract = require_contract(record)
+    return {key: contract.get(key) for key in CONTRACT_VIEW_KEYS if key in contract}
+
+
+def contract_views(records: Iterable[Any]) -> List[Dict[str, Any]]:
+    """Return compact views for every valid contract in ``records``."""
+    views: List[Dict[str, Any]] = []
+    for record in records:
+        contract = extract_contract(record)
+        if contract is not None:
+            views.append({key: contract.get(key) for key in CONTRACT_VIEW_KEYS if key in contract})
+    return views
+
+
 @dataclass(frozen=True)
 class AgentRunContract:
     run_id: Optional[str]
@@ -38,13 +177,11 @@ class AgentRunContract:
         return self.status in {"ok", "retried_ok", "failed", "rejected", "cancelled", "interrupted", "partial", "done"}
 
     def as_dict(self) -> Dict[str, Any]:
-        return {
-            "schema_version": self.schema_version,
+        body = {
             "run_id": self.run_id,
             "agent_id": self.agent_id,
             "runtime": self.runtime,
             "mode": self.mode,
-            "status": self.status,
             "goal": self.goal,
             "roles": list(self.roles),
             "current_role": self.current_role,
@@ -54,6 +191,12 @@ class AgentRunContract:
             "blocking_reasons": list(self.blocking_reasons),
             "is_terminal": self.is_terminal,
         }
+        return stamp_contract(
+            body,
+            kind="agent_run",
+            identity=self.run_id,
+            status=self.status,
+        )
 
 
 def multi_agent_contract(
@@ -80,6 +223,41 @@ def multi_agent_contract(
     ).as_dict()
 
 
+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 {})
+    timeline = list(run.get("timeline") or [])
+    retry_history = list(run.get("retry_history") or [])
+    roles = list(run.get("roles_run") or run.get("requested_roles") or [])
+    if not roles:
+        roles = [
+            str(item.get("role"))
+            for item in timeline
+            if isinstance(item, dict) and item.get("role")
+        ]
+    return AgentRunContract(
+        run_id=run.get("id") or run.get("run_id"),
+        agent_id=str(run.get("agent_id") or "agent:executor"),
+        runtime=runtime,
+        mode=str(run.get("mode") or "simulation"),
+        status=str(run.get("status") or "unknown"),
+        goal=str(run.get("input") or run.get("goal") or ""),
+        roles=roles,
+        current_role=run.get("current_role"),
+        retries=len(retry_history),
+        timeline=timeline,
+        artifacts=[
+            {
+                "type": "run_record",
+                "workspace_id": run.get("workspace_id"),
+                "graph_node_id": run.get("graph_node_id"),
+                "execution_mode": run.get("execution_mode"),
+            }
+        ],
+        blocking_reasons=[str(run.get("error"))] if run.get("error") else [],
+    ).as_dict()
+
+
 def single_agent_contract(
     *,
     ctx: Any,
@@ -105,3 +283,114 @@ def single_agent_contract(
         artifacts=[],
         blocking_reasons=list(blocking_reasons or []),
     ).as_dict()
+
+
+# ── Sibling-surface contract builders ───────────────────────────────────────
+# These wrap the other three observability surfaces into the same family so a
+# consumer can iterate agent runs, workflow runs, audit events and realtime
+# events through one envelope.
+
+def workflow_run_contract(run: Any) -> Dict[str, Any]:
+    """Wrap a workflow run dict (``WorkflowRun.as_dict()``) in the family envelope.
+
+    Accepts either a ``WorkflowRun`` instance or its serialized dict so the
+    engine can stamp without importing the dataclass here (avoids a cycle).
+    """
+    body = run.as_dict() if hasattr(run, "as_dict") else dict(run or {})
+    run_id = body.get("id") or body.get("run_id") or body.get("workflow_id")
+    workflow_id = body.get("workflow_id")
+    contract_body = {
+        "run_id": run_id,
+        "agent_id": f"workflow:{workflow_id or body.get('name') or 'workflow'}",
+        "runtime": "workflow",
+        "mode": body.get("mode") or "live",
+        "goal": body.get("name") or "workflow",
+        "roles": ["workflow"],
+        "current_role": body.get("current_node") or body.get("paused_node"),
+        "retries": 0,
+        "timeline": list(body.get("timeline") or []),
+        "artifacts": [
+            {
+                "type": "workflow_outputs",
+                "workflow_id": workflow_id,
+                "outputs": body.get("outputs") or {},
+                "pause": body.get("pause") or body.get("pending_approval"),
+            }
+        ],
+        "blocking_reasons": [str((body.get("outputs") or {}).get("error"))] if (body.get("outputs") or {}).get("error") else [],
+        "is_terminal": str(body.get("status") or "") in {"ok", "failed", "cancelled", "interrupted", "partial", "rejected"},
+    }
+    return stamp_contract(
+        contract_body,
+        kind="workflow_run",
+        identity=run_id,
+        status=str(body.get("status") or "unknown"),
+        timestamp=body.get("started_at") or body.get("created_at"),
+    )
+
+
+def audit_event_contract(event: Dict[str, Any]) -> Dict[str, Any]:
+    """Wrap a single audit-log event in the family envelope.
+
+    Audit events have no lifecycle ``status``; we expose the event type as the
+    status so the envelope stays uniform and filterable. Identity is a stable
+    ``event_type@timestamp`` key (audit events are append-only, not addressable).
+    """
+    body = dict(event or {})
+    event_type = str(body.get("event_type") or "event")
+    ts = body.get("timestamp")
+    identity = body.get("event_id") or (f"{event_type}@{ts}" if ts else event_type)
+    contract_body = {
+        "run_id": body.get("run_id"),
+        "agent_id": str(body.get("agent_id") or body.get("workflow_id") or f"audit:{event_type}"),
+        "runtime": "audit",
+        "mode": "event",
+        "goal": event_type,
+        "roles": [],
+        "current_role": None,
+        "retries": int(body.get("retries") or 0),
+        "timeline": [{"event": event_type, "timestamp": ts, "status": body.get("status") or event_type}],
+        "artifacts": [{"type": "audit_payload", "payload": body}],
+        "blocking_reasons": [],
+        "is_terminal": True,
+    }
+    return stamp_contract(
+        contract_body,
+        kind="audit_event",
+        identity=identity,
+        status=event_type,
+        timestamp=ts,
+    )
+
+
+def realtime_event_contract(event: Dict[str, Any]) -> Dict[str, Any]:
+    """Wrap a realtime bus event in the family envelope.
+
+    The bus already assigns a monotonic ``seq`` and ``received_at``; we reuse
+    those as identity and timestamp so the envelope is consistent with the
+    feed's own ordering guarantees.
+    """
+    body = dict(event or {})
+    seq = body.get("seq")
+    payload = body.get("payload") if isinstance(body.get("payload"), dict) else {}
+    contract_body = {
+        "run_id": payload.get("run_id") or body.get("run_id"),
+        "agent_id": str(payload.get("agent_id") or payload.get("workflow_id") or f"realtime:{body.get('area') or 'workspace'}"),
+        "runtime": "realtime",
+        "mode": "event",
+        "goal": str(body.get("event_type") or "event"),
+        "roles": [],
+        "current_role": payload.get("current_role"),
+        "retries": int(payload.get("retries") or 0),
+        "timeline": [{"event": body.get("event_type") or "event", "timestamp": body.get("received_at"), "payload": payload}],
+        "artifacts": [{"type": "realtime_payload", "payload": payload}],
+        "blocking_reasons": [str(payload.get("error"))] if payload.get("error") else [],
+        "is_terminal": str(payload.get("status") or "") in {"ok", "failed", "cancelled", "interrupted", "partial", "rejected"},
+    }
+    return stamp_contract(
+        contract_body,
+        kind="realtime_event",
+        identity=f"rt:{seq}" if seq is not None else None,
+        status=str(body.get("event_type") or "event"),
+        timestamp=body.get("received_at"),
+    )

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.3.0"
+MULTI_AGENT_VERSION = "7.5.0"
 
 AGENT_ROLES = ("researcher", "planner", "executor", "reviewer", "release")
 CORE_PIPELINE = ("planner", "executor", "reviewer")
@@ -286,6 +286,7 @@ class AgentRunResult:
     retry_history: List[Dict[str, Any]] = field(default_factory=list)
     plan_review: Dict[str, Any] = field(default_factory=dict)
     memory_snapshots: List[Dict[str, Any]] = field(default_factory=list)
+    goal: str = ""
     # "simulation" = deterministic LLM-free runner; "llm" = model-driven (v4 runtime).
     mode: str = "simulation"
 
@@ -306,8 +307,9 @@ class AgentRunResult:
             "retry_history": self.retry_history,
             "plan_review": self.plan_review,
             "memory_snapshots": self.memory_snapshots,
+            "goal": self.goal,
         }
-        payload["contract"] = multi_agent_contract(result=self, goal=self.output)
+        payload["contract"] = multi_agent_contract(result=self, goal=self.goal or self.output)
         return payload
 
 
@@ -800,5 +802,6 @@ class MultiAgentOrchestrator:
             retry_history=ctx.retry_history,
             plan_review=ctx.plan_review,
             memory_snapshots=ctx.memory_snapshots,
+            goal=ctx.goal,
             mode=self.mode,
         )

package/lattice_brain/workflow.py

@@ -27,6 +27,8 @@ from dataclasses import dataclass, field
 from datetime import datetime
 from typing import Any, Callable, Dict, List, Optional
 
+from lattice_brain.runtime.contracts import workflow_run_contract
+
 
 WORKFLOW_ENGINE_VERSION = "2.2.0"
 
@@ -198,7 +200,13 @@ class WorkflowRun:
     paused_context: Optional[Dict[str, Any]] = None
 
     def as_dict(self) -> Dict[str, Any]:
-        return {
+        # Native workflow-run shape is preserved unchanged for existing readers.
+        # A normalized ``agent-run-contract/v1`` projection is attached under
+        # ``contract`` so workflow runs sit in the same observability family as
+        # agent runs, audit events and realtime events (mirrors the audit-log
+        # and realtime-bus convention). The projection is built from the native
+        # dict — never from ``self`` — so it cannot recurse back into as_dict().
+        body = {
             "workflow_id": self.workflow_id,
             "name": self.name,
             "status": self.status,
@@ -211,6 +219,8 @@ class WorkflowRun:
             "pending_approval": self.pending_approval,
             "paused_context": self.paused_context,
         }
+        body["contract"] = workflow_run_contract(body)
+        return body
 
 
 class ApprovalRequired(Exception):

package/latticeai/__init__.py

@@ -1,3 +1,3 @@
 """Lattice AI - modular server package."""
 
-__version__ = "7.3.0"
+__version__ = "7.5.0"

package/latticeai/api/agents.py

@@ -111,7 +111,7 @@ def create_agents_router(
     async def agent_runs(request: Request):
         require_user(request)
         scope = gate_read(request)
-        return store.list_agents(workspace_id=scope)
+        return runtime.list_runs(scope=scope)
 
     @router.get("/agents/api/handoffs")
     async def agent_handoffs(request: Request, run_id: str = ""):
@@ -124,7 +124,7 @@ def create_agents_router(
         require_user(request)
         scope = gate_read(request)
         try:
-            return {"run": store.get_agent_run(run_id, workspace_id=scope)}
+            return runtime.get_run(run_id, scope=scope)
         except FileNotFoundError as exc:
             raise HTTPException(status_code=404, detail=f"Agent run not found: {run_id}") from exc
 
@@ -133,7 +133,7 @@ def create_agents_router(
         require_user(request)
         scope = gate_read(request)
         try:
-            return {"replay": store.replay_agent_run(run_id, workspace_id=scope)}
+            return runtime.replay(run_id, scope=scope)
         except FileNotFoundError as exc:
             raise HTTPException(status_code=404, detail=f"Agent run not found: {run_id}") from exc
 

package/latticeai/api/realtime.py

@@ -17,6 +17,7 @@ from fastapi.responses import StreamingResponse
 from pydantic import BaseModel
 
 from latticeai.api.ui_redirects import app_redirect
+from lattice_brain.runtime.contracts import contract_views
 
 
 class PresenceRequest(BaseModel):
@@ -63,7 +64,8 @@ def create_realtime_router(
     async def realtime_feed(request: Request, limit: int = 50):
         user = require_user(request)
         scope = allowed_scopes(user or None)
-        return {"events": bus.recent(limit=limit, workspace_scope=scope), "stats": bus.stats()}
+        events = bus.recent(limit=limit, workspace_scope=scope)
+        return {"events": events, "contracts": contract_views(events), "stats": bus.stats()}
 
     @router.get("/realtime/presence")
     async def realtime_presence(request: Request):

package/latticeai/core/audit.py

@@ -5,9 +5,12 @@ import logging
 import os
 import re
 import threading
+import hashlib
 from pathlib import Path
 from typing import Any, Callable, Dict, List, Optional
 
+from lattice_brain.runtime.contracts import audit_event_contract
+
 from . import timezones
 from .security import redact_secrets
 
@@ -42,12 +45,21 @@ def get_audit_log(audit_file: Path) -> List[Dict]:
 def append_audit_event(audit_file: Path, event_type: str, **payload) -> None:
     try:
         safe_payload = redact_secrets(payload)
+        timestamp = timezones.now_iso()
+        event_hash = hashlib.sha256(
+            json.dumps([event_type, timestamp, safe_payload], ensure_ascii=False, sort_keys=True, default=str).encode("utf-8")
+        ).hexdigest()[:24]
         event = {
+            "event_id": f"audit-{event_hash}",
             "event_type": event_type,
             # item 7: 대시보드 "오늘" 계산과 동일한 시간대 기준으로 기록한다.
-            "timestamp": timezones.now_iso(),
+            "timestamp": timestamp,
             **safe_payload,
         }
+        # Stamp the agent-run-contract/v1 family envelope so audit rows are
+        # uniform with agent/workflow/realtime records. Additive — existing
+        # readers ignore the extra keys; new consumers can filter by family.
+        event["contract"] = audit_event_contract(event)
         with _history_lock:
             events = get_audit_log(audit_file)
             events.append(event)
@@ -236,6 +248,8 @@ def build_admin_audit_report(
 
 def _public_audit_event(event: Dict) -> Dict:
     allowed = {
+        # Stable event id + nested agent-run-contract/v1 family projection.
+        "event_id", "contract",
         "event_type", "timestamp", "role", "user_email", "user_nickname", "source",
         "conversation_id", "workspace_id", "command", "scope", "target_email", "filename", "mime_type",
         "ext", "bytes", "extracted_chars", "graph_node", "keep_last", "removed", "kept",

package/latticeai/core/marketplace.py

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

package/latticeai/core/realtime.py

@@ -32,6 +32,8 @@ import threading
 from datetime import datetime
 from typing import Any, AsyncIterator, Dict, List, Optional, Set
 
+from lattice_brain.runtime.contracts import realtime_event_contract
+
 
 REALTIME_VERSION = "2.2.0"
 _FEED_LIMIT = 200
@@ -99,6 +101,7 @@ class RealtimeBus:
                 "payload": event.get("payload", {}),
                 **{k: v for k, v in event.items() if k not in {"area", "event_type", "workspace_id", "payload"}},
             }
+            enriched["contract"] = realtime_event_contract(enriched)
             self._feed.append(enriched)
             if len(self._feed) > _FEED_LIMIT:
                 self._feed = self._feed[-_FEED_LIMIT:]

package/latticeai/core/workspace_os.py

@@ -18,8 +18,10 @@ from datetime import datetime
 from pathlib import Path
 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.3.0"
+
+WORKSPACE_OS_VERSION = "7.5.0"
 
 # Workspace types separate single-user Personal workspaces from shared
 # Organization workspaces. Both keep the same local-first JSON store; the type
@@ -526,6 +528,7 @@ class WorkspaceOSStore:
             "workspace_id": self._resolve_scope(workspace_id, state),
             "payload": payload,
         }
+        event["contract"] = realtime_event_contract({"seq": event["id"], "received_at": event["timestamp"], **event})
         state.setdefault("timeline", []).append(event)
         self.save_state(state)
         if self.event_sink is not None:
@@ -1565,6 +1568,13 @@ class WorkspaceOSStore:
         if status == "failed":
             self._emit_execution_event(area="agent", event_type="execution_failed", payload={"run_id": run["id"], "agent_id": agent_id, "status": status}, workspace_id=resolved_workspace)
         self.record_timeline_event("agent", "agent_run", {"run_id": run["id"], "agent_id": agent_id, "status": status}, workspace_id=resolved_workspace)
+        run["contract"] = run_record_contract(run)
+        state = self.load_state()
+        for item in _listify(state.get("agent_runs")):
+            if item.get("id") == run["id"]:
+                item["contract"] = run["contract"]
+                break
+        self.save_state(state)
         return run
 
     def update_agent_run(
@@ -1636,6 +1646,13 @@ class WorkspaceOSStore:
                 run["graph_error"] = str(exc)
 
         self.save_state(state)
+        run["contract"] = run_record_contract(run)
+        state = self.load_state()
+        for item in _listify(state.get("agent_runs")):
+            if item.get("id") == run_id:
+                item["contract"] = run["contract"]
+                break
+        self.save_state(state)
 
         timeline = run.get("timeline") or []
         if len(timeline) > old_timeline_len:
@@ -1774,6 +1791,13 @@ class WorkspaceOSStore:
         elif status in {"ok", "partial"}:
             self._emit_execution_event(area="workflow", event_type="workflow_completed", payload={"run_id": run["id"], "workflow_id": workflow_id, "status": status}, workspace_id=resolved_workspace)
         self.record_timeline_event("workflow", "workflow_run", {"run_id": run["id"], "workflow_id": workflow_id, "status": status}, workspace_id=resolved_workspace)
+        run["contract"] = workflow_run_contract(run)
+        state = self.load_state()
+        for item in _listify(state.get("workflow_runs")):
+            if item.get("id") == run["id"]:
+                item["contract"] = run["contract"]
+                break
+        self.save_state(state)
         return run
 
     def update_workflow_run(
@@ -1835,6 +1859,13 @@ class WorkspaceOSStore:
                 run["graph_error"] = str(exc)
 
         self.save_state(state)
+        run["contract"] = workflow_run_contract(run)
+        state = self.load_state()
+        for item in _listify(state.get("workflow_runs")):
+            if item.get("id") == run_id:
+                item["contract"] = run["contract"]
+                break
+        self.save_state(state)
 
         timeline = run.get("timeline") or []
         if len(timeline) > old_timeline_len:
@@ -2053,6 +2084,7 @@ class WorkspaceOSStore:
             "run_id": run_id,
             "status": run.get("status"),
             "workspace_id": self._record_workspace(run),
+            "contract": run.get("contract") or run_record_contract(run),
             "replayable": True,
             "frames": self._replay_frames(run, kind="agent"),
             "handoffs": run.get("handoffs") or [],
@@ -2068,6 +2100,7 @@ class WorkspaceOSStore:
             "run_id": run_id,
             "status": run.get("status"),
             "workspace_id": self._record_workspace(run),
+            "contract": run.get("contract") or workflow_run_contract(run),
             "replayable": True,
             "frames": self._replay_frames(run, kind="workflow"),
             "outputs": run.get("outputs") or {},

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ltcai",
-  "version": "7.3.0",
+  "version": "7.5.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": {
@@ -115,8 +115,8 @@
     "@playwright/test": "^1.60.0",
     "@tailwindcss/postcss": "^4.3.0",
     "@tanstack/react-query": "^5.101.0",
-    "@tauri-apps/api": "^2.0.0",
-    "@tauri-apps/cli": "^2.0.0",
+    "@tauri-apps/api": "^2.11.1",
+    "@tauri-apps/cli": "^2.11.3",
     "@types/cytoscape": "^3.21.9",
     "@types/react": "^19.2.17",
     "@types/react-dom": "^19.2.3",
@@ -138,5 +138,8 @@
     "typescript": "^5.9.3",
     "vite": "^8.0.16",
     "zustand": "^5.0.14"
+  },
+  "overrides": {
+    "js-yaml": "^4.2.0"
   }
 }