ltcai 10.6.2 → 10.7.0

package/docs/ONBOARDING.md

@@ -1,6 +1,6 @@
 # Lattice AI Onboarding
 
-Current release: **10.6.2 — Ask First**.
+Current release: **10.7.0 — Plain Surface**.
 
 The first-run goal is a five-minute path from "I opened the app" to "my Brain
 has a source, a question, and proof." This page is the product contract behind

package/docs/OPERATIONS.md

@@ -1,4 +1,4 @@
-# Lattice AI — Operations Guide (v10.6.2)
+# Lattice AI — Operations Guide (v10.7.0)
 
 > **Status: canonical** — kept in sync with the current release. Storage layout
 > below reflects the SQLite live Brain store and workspace scoping, not the
@@ -162,3 +162,31 @@ Ctrl+C  또는  kill <pid>
 ```
 
 서버는 종료 시 진행 중인 HTTP 요청을 완료한 후 종료됩니다 (graceful shutdown — uvicorn 기본 동작).
+
+## 10. 릴리스 증거 캡처 순서 (레이아웃·UI 변경 후)
+
+`scripts/capture_release_evidence.mjs` 의 `assertNotOverwritingTaggedRelease()` 는
+`package.json` 버전과 동일한 git 태그(`vX.Y.Z`)가 이미 있으면 **즉시 exit 1** 한다.
+레이아웃/UI를 바꾼 뒤 스크린샷을 다시 찍을 때는 반드시 아래 순서를 지킨다.
+
+1. **버전 범프 먼저** — `node scripts/run_python.mjs scripts/bump_version.py`
+   (또는 동등한 package/pyproject/extension 버전 일괄 상향). 캡처 **전에** 한다.
+2. `npm run build:assets` — 캡처는 빌드된 `static/app` 을 본다.
+3. `npm run release:evidence` — `output/release/v<새버전>/` 에만 기록한다.
+   캡처 → 오래된 버전 정리 → **픽셀 델타 검사**까지 한 번에 돈다.
+4. 결속 검사 — `SCREENSHOT_INDEX.md` 의 `asset-manifest.sha256` 과
+   `mock-server.sha256` 이 각각 `static/app/asset-manifest.json`,
+   `tests/visual/mock_server.cjs` 와 일치해야 `npm run lint` 가 통과한다.
+
+레이아웃을 바꿨다고 보고했는데 배치는 그대로인 경우를 잡기 위해 v10.7.0 부터
+`scripts/check_screenshot_pixel_delta.py` 가 12개 캡처를 직전 버전과 대조한다
+(`npm run check:screenshot-delta` 로 단독 실행). 정적 화면은 1.5%, 애니메이션이
+있는 화면은 8% 이상 픽셀이 달라져야 통과한다. 문구만 고친 화면은 여기서 실패로
+잡히므로, 실패했다면 캡처가 아니라 레이아웃을 다시 본다. 직전 버전 디렉터리가
+정리되어 없으면 기준선을 꺼낼 태그를 체크아웃한 뒤 다시 돌린다.
+
+이미 태그가 찍힌 버전의 `output/release/vX.Y.Z/` 를 WIP UI로 덮으면 그 릴리스
+증거가 영구히 거짓이 된다. 미리보기만 필요하면
+`LTCAI_RELEASE_EVIDENCE_DIR=/tmp/lattice-preview npm run release:evidence` 로
+게시 경로 밖을 쓴다. 태그된 버전의 원본 증거가 오염됐다면 태그 시점 트리에서
+해당 디렉터리를 복원한 뒤, 새 버전 디렉터리에 다시 캡처한다.

package/docs/TRUST_MODEL.md

@@ -1,6 +1,6 @@
 # Lattice AI Trust Model
 
-Current release: **10.6.2 — Ask First**.
+Current release: **10.7.0 — Plain Surface**.
 
 Lattice AI is local-first, explicit about external communication, and honest
 when a capability is unavailable.

package/docs/WHY_LATTICE.md

@@ -1,6 +1,6 @@
 # Why Lattice AI Exists
 
-Current release: **10.6.2 — Ask First**.
+Current release: **10.7.0 — Plain Surface**.
 
 **Lattice AI is a local-first Digital Brain that keeps your knowledge durable
 across any AI model.**

package/docs/kg-schema.md

@@ -1,6 +1,6 @@
 # Knowledge Graph Schema
 
-Current release: **10.6.2 — Ask First**.
+Current release: **10.7.0 — Plain Surface**.
 
 명세 출처: `lattice_ai_full_spec.pptx` 슬라이드 20·21·22
 구현: `lattice_brain/graph/schema.py`

package/lattice_brain/__init__.py

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

package/lattice_brain/runtime/multi_agent.py

@@ -47,7 +47,7 @@ from typing import Any, Callable, Dict, List, Optional
 from ..utils import now_iso as _now
 from .contracts import multi_agent_contract
 
-MULTI_AGENT_VERSION = "10.6.2"
+MULTI_AGENT_VERSION = "10.7.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__ = "10.6.2"
+__version__ = "10.7.0"

package/latticeai/api/admin.py

@@ -159,6 +159,78 @@ def create_admin_router(
             "last_message_at": history[-1].get("timestamp") if history else None,
         }
 
+    @router.get("/admin/health-summary")
+    async def admin_health_summary(request: Request):
+        """One-line admin health for the calm console header (layout rebuild).
+
+        Aggregates existing admin surfaces — no new persistence. ``status`` is
+        ``attention`` when any issue is present, else ``ok``.
+        """
+        _, users = require_admin(request)
+        issues: List[Dict[str, Any]] = []
+
+        disabled = sum(1 for user in users.values() if user.get("disabled"))
+        if disabled:
+            issues.append({
+                "area": "users",
+                "severity": "warning",
+                "message": f"{disabled} disabled user(s)",
+            })
+
+        try:
+            report = build_sensitivity_report(_scoped_history(request)) or {}
+            severity = ((report.get("summary") or {}).get("severity_counts") or {})
+            high = int(severity.get("high") or 0)
+            if high:
+                issues.append({
+                    "area": "security",
+                    "severity": "high",
+                    "message": f"{high} high-risk event(s)",
+                })
+        except Exception as exc:
+            logging.warning("admin health-summary sensitivity failed: %s", exc)
+
+        if enable_graph:
+            try:
+                stats = get_graph_stats() or {}
+                if isinstance(stats, dict) and stats.get("error"):
+                    issues.append({
+                        "area": "brain_ops",
+                        "severity": "warning",
+                        "message": "Knowledge graph unavailable",
+                    })
+            except Exception as exc:
+                issues.append({
+                    "area": "brain_ops",
+                    "severity": "warning",
+                    "message": str(exc)[:160],
+                })
+
+        if product_hardening_status is not None:
+            try:
+                res = product_hardening_status()
+                hardening = res if isinstance(res, dict) else {}
+                startup = hardening.get("startup") if isinstance(hardening, dict) else {}  # type: ignore[union-attr]
+                if isinstance(startup, dict) and startup.get("network_exposed"):
+                    issues.append({
+                        "area": "runtime_trust",
+                        "severity": "warning",
+                        "message": "Server is network-exposed",
+                    })
+            except Exception as exc:
+                logging.warning("admin health-summary hardening failed: %s", exc)
+
+        # issue_count is a first-class field (not client-derived from issues[]).
+        # AdminConsole reads healthData.issue_count for the header sentence;
+        # falling back to || 1 when the field is missing misreports multi-issue
+        # states as a single problem.
+        issue_count = len(issues)
+        return {
+            "status": "attention" if issue_count else "ok",
+            "issue_count": issue_count,
+            "issues": issues,
+        }
+
     @router.get("/admin/stats")
     async def admin_stats(request: Request):
         require_admin(request)

package/latticeai/api/automation_intelligence.py

@@ -44,6 +44,65 @@ class AutomationRunNowRequest(BaseModel):
     dry_run: bool = True
 
 
+def _ensure_activity_run_source(run: Any) -> dict[str, Any]:
+    """Guarantee the Act feed ``source`` field for 레시피/목표 badge split.
+
+    Capture 09 (``frontend/src/pages/Act.tsx``) distinguishes workflow vs agent
+    with ``run.source === "workflow" || Boolean(run.workflow_id)``. A store that
+    omits both collapses every row to "목표" and silently undoes the merged
+    timeline redesign. Prefer an explicit ``source``; otherwise infer from
+    ``workflow_id`` / ``agent_id``.
+    """
+    if not isinstance(run, dict):
+        return {"source": "agent", "id": None, "title": "", "status": ""}
+    row = dict(run)
+    source = str(row.get("source") or "").strip().lower()
+    if source in {"workflow", "agent"}:
+        row["source"] = source
+        return row
+    if row.get("workflow_id"):
+        row["source"] = "workflow"
+        return row
+    if row.get("agent_id"):
+        row["source"] = "agent"
+        return row
+    # Last resort: keep any non-empty legacy value, else agent.
+    row["source"] = source if source else "agent"
+    return row
+
+
+def _with_run_truncation_meta(payload: Any, *, capped: int) -> dict[str, Any]:
+    """Guarantee ``total`` / ``truncated`` on combined-run payloads.
+
+    Stores that already implement :meth:`list_combined_runs` may return only
+    ``runs``. The Act feed needs to say how many rows are hidden when the
+    server slices agent+workflow history (default cap 20).
+
+    Every run is also passed through :func:`_ensure_activity_run_source` so the
+    레시피/목표 badge never loses its discriminator.
+    """
+    if not isinstance(payload, dict):
+        return {"runs": [], "total": 0, "truncated": False}
+    runs = [_ensure_activity_run_source(run) for run in (payload.get("runs") or [])]
+    if "total" in payload:
+        try:
+            total = max(0, int(payload.get("total") or 0))
+        except (TypeError, ValueError):
+            total = len(runs)
+    else:
+        total = len(runs)
+    if "truncated" in payload:
+        truncated = bool(payload.get("truncated"))
+    else:
+        truncated = total > len(runs) or total > capped
+    # Prefer the larger of declared total and visible rows so a buggy store
+    # never claims fewer total than the list it just returned.
+    total = max(total, len(runs))
+    if total > len(runs):
+        truncated = True
+    return {**payload, "runs": runs, "total": total, "truncated": truncated}
+
+
 def _run_now_wait_seconds() -> float:
     raw = os.environ.get("LATTICEAI_AUTOMATION_RUN_NOW_WAIT", "30")
     try:
@@ -283,6 +342,59 @@ def create_automation_intelligence_router(
             payload["review_item_id"] = review_item.get("id")
         return payload
 
+    def _combined_runs(request: Request, limit: int = 20) -> dict[str, Any]:
+        require_user(request)
+        scope = gate_read(request)
+        capped = max(1, min(int(limit or 20), 100))
+        if hasattr(store, "list_combined_runs"):
+            payload = store.list_combined_runs(limit=capped, workspace_id=scope)
+            return _with_run_truncation_meta(payload, capped=capped)
+        # Store without the helper: merge the two existing listings in place.
+        agent_listing = (
+            store.list_agents(workspace_id=scope)
+            if hasattr(store, "list_agents")
+            else {"runs": []}
+        )
+        # Pull a wide window so agent+workflow merge can still fill ``capped``
+        # after sort; true total is the unscoped merge size before slice.
+        workflow_listing = (
+            store.list_workflow_runs(limit=max(capped, 100), workspace_id=scope)
+            if hasattr(store, "list_workflow_runs")
+            else {"runs": []}
+        )
+        from latticeai.core.workspace_runs import WorkspaceRuns
+
+        rows = []
+        for run in agent_listing.get("runs") or []:
+            rows.append(
+                _ensure_activity_run_source(
+                    WorkspaceRuns.activity_run_row(run, source="agent")
+                )
+            )
+        for run in workflow_listing.get("runs") or []:
+            rows.append(
+                _ensure_activity_run_source(
+                    WorkspaceRuns.activity_run_row(run, source="workflow")
+                )
+            )
+        rows.sort(key=lambda row: str(row.get("started_at") or ""), reverse=True)
+        total = len(rows)
+        return {
+            "runs": rows[:capped],
+            "total": total,
+            "truncated": total > capped,
+        }
+
+    @router.get("/api/activity/runs")
+    async def activity_runs(request: Request, limit: int = 20):
+        """Unified agent + workflow run timeline (layout rebuild screen 09)."""
+        return _combined_runs(request, limit=limit)
+
+    @router.get("/automations/runs/combined")
+    async def automations_runs_combined(request: Request, limit: int = 20):
+        """Alias used by the frontend handoff for the same combined timeline."""
+        return _combined_runs(request, limit=limit)
+
     return router
 
 

package/latticeai/api/knowledge_graph.py

@@ -6,6 +6,7 @@ remains as a deprecation shim. Route paths and response shapes are frozen by
 data endpoints back the v3 SPA (Files, Hybrid Search, graph explorer).
 """
 
+from datetime import datetime
 from pathlib import Path
 from typing import Any, Callable, Dict, List, Optional
 
@@ -18,6 +19,7 @@ from latticeai.api.workspace_scope import (
     resolve_workspace_scope,
     workspace_scope_from_request,
 )
+from latticeai.core.quiet import quiet
 
 
 class KnowledgeGraphIngestRequest(BaseModel):
@@ -71,6 +73,25 @@ def _format_context(matches: list, limit: int) -> str:
     return "\n".join(lines)
 
 
+def _pipeline_stage_view(*, count: int, pending: int) -> Dict[str, Any]:
+    """Derive a coherent journey-ribbon stage from count + pending.
+
+    Invariants (enforced for layout-rebuild Capture screen 11):
+    - ``pending > 0`` → ``working``
+    - ``pending == 0`` and ``count > 0`` → ``done`` (never ``waiting``)
+    - ``pending == 0`` and ``count == 0`` → ``waiting`` (nothing arrived yet)
+    """
+    safe_count = max(0, int(count))
+    safe_pending = max(0, int(pending))
+    if safe_pending > 0:
+        status = "working"
+    elif safe_count > 0:
+        status = "done"
+    else:
+        status = "waiting"
+    return {"count": safe_count, "pending": safe_pending, "status": status}
+
+
 def create_knowledge_graph_router(
     *,
     get_graph: Callable[[], Any],
@@ -248,6 +269,118 @@ def create_knowledge_graph_router(
     async def knowledge_graph_stats(request: Request):
         return _scoped_stats(request)
 
+    @router.get("/knowledge-graph/pipeline/status")
+    async def knowledge_graph_pipeline_status(request: Request):
+        """Per-stage counts + status for the Capture 3-step journey ribbon.
+
+        Aggregates existing store data only — no schema change. Top-level
+        ``received`` / ``extracted`` / ``connected`` stay for simple clients;
+        ``stages`` is the single source of truth for count, pending, and
+        status (``done`` / ``working`` / ``waiting``). Keys are omitted when
+        a value cannot be computed (never faked as 0 when the underlying
+        source is unavailable).
+        """
+        kg, allowed = _scoped(request)
+        received: Optional[int] = None
+        extracted: Optional[int] = None
+        connected: Optional[int] = None
+        index_pending: Optional[int] = None
+
+        try:
+            docs_payload = kg.list_documents(10_000)
+            documents = list(docs_payload.get("documents") or [])
+            if allowed is not None:
+                documents = _filter_scoped(kg, documents, allowed)
+            received = len(documents)
+            extracted = sum(
+                1
+                for doc in documents
+                if doc.get("indexed") or int(doc.get("chunks") or 0) > 0
+            )
+        except Exception:
+            quiet()
+
+        try:
+            stats = _scoped_stats(request)
+            edges = stats.get("edges")
+            if isinstance(edges, dict):
+                connected = sum(int(value or 0) for value in edges.values())
+            elif isinstance(edges, (int, float)) and not isinstance(edges, bool):
+                connected = int(edges)
+            elif isinstance(stats.get("v2"), dict):
+                v2_edges = stats["v2"].get("edges")
+                if isinstance(v2_edges, (int, float)) and not isinstance(v2_edges, bool):
+                    connected = int(v2_edges)
+            if received is None:
+                nodes = stats.get("nodes")
+                if isinstance(nodes, dict):
+                    received = sum(
+                        int(value or 0)
+                        for key, value in nodes.items()
+                        if str(key).lower() != "chunk"
+                    )
+                elif isinstance(nodes, (int, float)) and not isinstance(nodes, bool):
+                    received = int(nodes)
+        except Exception:
+            quiet()
+
+        index_fn = getattr(kg, "index_status", None)
+        if callable(index_fn):
+            try:
+                index = index_fn() or {}
+                if received is None and index.get("source_items") is not None:
+                    received = int(index.get("source_items") or 0)
+                if extracted is None and index.get("ready_items") is not None:
+                    extracted = int(index.get("ready_items") or 0)
+                if index.get("pending_items") is not None:
+                    index_pending = max(0, int(index.get("pending_items") or 0))
+                elif index.get("pending") is not None:
+                    index_pending = max(0, int(index.get("pending") or 0))
+            except Exception:
+                quiet()
+
+        payload: Dict[str, Any] = {}
+        if received is not None:
+            payload["received"] = max(0, int(received))
+        if extracted is not None:
+            payload["extracted"] = max(0, int(extracted))
+        if connected is not None:
+            payload["connected"] = max(0, int(connected))
+
+        if payload:
+            stages: Dict[str, Dict[str, Any]] = {}
+            if "received" in payload:
+                # Once listed as a document it has been received — no backlog.
+                stages["received"] = _pipeline_stage_view(
+                    count=payload["received"], pending=0
+                )
+            if "extracted" in payload:
+                # Prefer vector-index backlog; fall back to docs not yet chunked.
+                if index_pending is not None:
+                    extract_pending = index_pending
+                elif "received" in payload:
+                    extract_pending = max(
+                        0, int(payload["received"]) - int(payload["extracted"])
+                    )
+                else:
+                    extract_pending = 0
+                stages["extracted"] = _pipeline_stage_view(
+                    count=payload["extracted"], pending=extract_pending
+                )
+            if "connected" in payload:
+                # Connections are graph edges; backlog only when index reports
+                # pending items that still need linking (reuse extract backlog
+                # only when we have no better signal — 0 when graph is ready).
+                connect_pending = 0
+                if index_pending is not None and payload["connected"] == 0:
+                    connect_pending = index_pending
+                stages["connected"] = _pipeline_stage_view(
+                    count=payload["connected"], pending=connect_pending
+                )
+            payload["stages"] = stages
+            payload["updated_at"] = datetime.now().isoformat(timespec="seconds")
+        return payload
+
     @router.get("/knowledge-graph/schema")
     async def knowledge_graph_schema(request: Request):
         stats = _scoped_stats(request)

package/latticeai/api/static_routes.py

@@ -34,6 +34,30 @@ PRODUCTION_CSP = (
 INVITE_COOKIE_NAME = "lattice_invite"
 INVITE_COOKIE_TTL_SECONDS = 60 * 60 * 24 * 7
 
+# Host-capacity plain-language judgment for System basic mode (layout rebuild).
+# Thresholds live here so the frontend never re-derives copy from raw percents.
+SYSINFO_READINESS_ROOMY_MAX = 55.0
+SYSINFO_READINESS_TIGHT_MAX = 80.0
+
+
+def host_capacity_readiness(
+    *,
+    cpu_pct: float = 0.0,
+    ram_pct: float = 0.0,
+    gpu_mem_pct: float = 0.0,
+) -> str:
+    """Map host telemetry to a single plain-language readiness bucket.
+
+    Returns one of ``roomy`` / ``tight`` / ``low``. The product uses this so
+    basic-mode System copy and advanced-mode numbers share one judgment.
+    """
+    load = max(float(cpu_pct or 0.0), float(ram_pct or 0.0), float(gpu_mem_pct or 0.0))
+    if load <= SYSINFO_READINESS_ROOMY_MAX:
+        return "roomy"
+    if load <= SYSINFO_READINESS_TIGHT_MAX:
+        return "tight"
+    return "low"
+
 
 def _sign_invite_cookie(secret: str, *, now: Optional[int] = None) -> str:
     """Create an expiring, nonce-bearing invite-gate capability cookie."""
@@ -250,7 +274,11 @@ def create_static_routes_router(
     
     @api_router.get("/local/sysinfo")
     async def local_sysinfo(request: Request):
-        """CPU / RAM / GPU(MLX) 사용량을 반환합니다."""
+        """CPU / RAM / GPU(MLX) usage plus a plain-language readiness bucket.
+
+        ``readiness`` is ``roomy`` | ``tight`` | ``low`` so basic System copy
+        does not re-interpret raw percents on the client.
+        """
         require_user(request)
         import re as _re
         result: Dict[str, Any] = {
@@ -258,6 +286,7 @@ def create_static_routes_router(
             "ram_pct": 0.0,
             "gpu_mem_pct": 0.0,
             "gpu_mem_gb": 0.0,
+            "readiness": "roomy",
         }
         try:
             # CPU
@@ -291,6 +320,11 @@ def create_static_routes_router(
                 quiet()
         except Exception as e:
             result["error"] = str(e)
+        result["readiness"] = host_capacity_readiness(
+            cpu_pct=float(result.get("cpu_pct") or 0.0),
+            ram_pct=float(result.get("ram_pct") or 0.0),
+            gpu_mem_pct=float(result.get("gpu_mem_pct") or 0.0),
+        )
         return result
 
     return StaticRoutesBundle(

package/latticeai/core/legacy_compatibility.py

@@ -13,7 +13,7 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Any, Dict, List
 
-LEGACY_COMPATIBILITY_VERSION = "10.6.2"
+LEGACY_COMPATIBILITY_VERSION = "10.7.0"
 
 
 @dataclass(frozen=True)

package/latticeai/core/marketplace.py

@@ -10,7 +10,7 @@ from __future__ import annotations
 from copy import deepcopy
 from typing import Any, Dict, List, Optional
 
-MARKETPLACE_VERSION = "10.6.2"
+MARKETPLACE_VERSION = "10.7.0"
 TEMPLATE_KINDS = ("plugin", "workflow", "agent", "ingestion_bridge")
 
 

package/latticeai/core/workspace_os.py

@@ -883,6 +883,9 @@ class WorkspaceOSStore:
     def list_workflow_runs(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
         return self.runs.list_workflow_runs(*args, **kwargs)
 
+    def list_combined_runs(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
+        return self.runs.list_combined_runs(*args, **kwargs)
+
     def mark_workflow_run_resolved(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
         return self.runs.mark_workflow_run_resolved(*args, **kwargs)
 

package/latticeai/core/workspace_os_constants.py

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