npm - ltcai - Versions diffs - 9.9.3 → 9.9.4 - Mend

ltcai 9.9.3 → 9.9.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (81) hide show

package/README.md +43 -38
package/docs/CHANGELOG.md +65 -0
package/docs/COMMUNITY_AND_PLUGINS.md +1 -1
package/docs/DEVELOPMENT.md +1 -1
package/docs/ONBOARDING.md +1 -1
package/docs/OPERATIONS.md +1 -1
package/docs/SURFACE_PARITY.md +47 -0
package/docs/TRUST_MODEL.md +1 -1
package/docs/WHY_LATTICE.md +1 -1
package/docs/kg-schema.md +1 -1
package/lattice_brain/__init__.py +1 -1
package/lattice_brain/graph/_kg_common.py +335 -0
package/lattice_brain/graph/discovery_index.py +8 -1
package/lattice_brain/graph/ingest.py +43 -9
package/lattice_brain/graph/projection.py +221 -37
package/lattice_brain/graph/retrieval.py +61 -12
package/lattice_brain/graph/retrieval_policy.py +174 -0
package/lattice_brain/graph/retrieval_vector.py +122 -2
package/lattice_brain/portability.py +41 -12
package/lattice_brain/runtime/multi_agent.py +1 -1
package/latticeai/__init__.py +1 -1
package/latticeai/api/chat.py +6 -0
package/latticeai/api/chat_agent_http.py +175 -6
package/latticeai/api/chat_intents.py +37 -18
package/latticeai/api/chat_stream.py +76 -2
package/latticeai/api/knowledge_graph.py +35 -1
package/latticeai/core/agent.py +264 -9
package/latticeai/core/enterprise.py +5 -0
package/latticeai/core/file_generation.py +130 -5
package/latticeai/core/legacy_compatibility.py +1 -1
package/latticeai/core/marketplace.py +1 -1
package/latticeai/core/run_store.py +243 -0
package/latticeai/core/workspace_os.py +1 -1
package/latticeai/models/router.py +25 -12
package/latticeai/services/architecture_readiness.py +1 -1
package/latticeai/services/command_center.py +90 -1
package/latticeai/services/folder_watch.py +5 -0
package/latticeai/services/funnel_metrics.py +9 -1
package/latticeai/services/product_readiness.py +1 -1
package/latticeai/services/search_service.py +43 -13
package/package.json +1 -1
package/scripts/bench_agent_smoke.py +410 -0
package/scripts/check_current_release_docs.mjs +1 -1
package/scripts/funnel_soft_gate.py +192 -0
package/src-tauri/Cargo.lock +1 -1
package/src-tauri/Cargo.toml +1 -1
package/src-tauri/tauri.conf.json +1 -1
package/static/app/asset-manifest.json +29 -28
package/static/app/assets/Act-BCmTU0E2.js +1 -0
package/static/app/assets/{Brain-DEY9jLVt.js → Brain-CTnjox7w.js} +2 -2
package/static/app/assets/BrainHome-BJ3sFNX0.js +2 -0
package/static/app/assets/BrainSignals-C52lwZVD.js +1 -0
package/static/app/assets/{Capture-CVZ09QXi.js → Capture-B6vBhFa3.js} +1 -1
package/static/app/assets/{CommandPalette-DepwOQFv.js → CommandPalette-90u9FWFH.js} +1 -1
package/static/app/assets/{Library-Bp0n-HlW.js → Library-pKCK0_tk.js} +1 -1
package/static/app/assets/{LivingBrain-DxP4efJF.js → LivingBrain-Jlf2wFqI.js} +1 -1
package/static/app/assets/{ProductFlow-DRbm7NEq.js → ProductFlow-yg1fKP1P.js} +1 -1
package/static/app/assets/{ReviewCard-C4HAO7A3.js → ReviewCard-DWvD7n9h.js} +1 -1
package/static/app/assets/{System-ByQcmJW-.js → System-BAEuHqNY.js} +1 -1
package/static/app/assets/{bot-BNDyZLR7.js → bot-nB_buEZD.js} +1 -1
package/static/app/assets/circle-pause-DLNw6Ucp.js +1 -0
package/static/app/assets/{circle-play-BkhdcHgd.js → circle-play-B-IsFL1y.js} +1 -1
package/static/app/assets/{cpu-C6jjYm6i.js → cpu-CEPBHaBl.js} +1 -1
package/static/app/assets/{folder-open-DjGIvDBQ.js → folder-open-hmN0N9cX.js} +1 -1
package/static/app/assets/{hard-drive-BlSbwSaT.js → hard-drive-CBV_B_Yd.js} +1 -1
package/static/app/assets/{index-Bge3DXW7.css → index-7FAfYm4v.css} +1 -1
package/static/app/assets/{index-CHu7cgj3.js → index-DrmOCySv.js} +3 -3
package/static/app/assets/{input-DVDI0YR3.js → input-gtVCg-ll.js} +1 -1
package/static/app/assets/{navigation-BddhEWA0.js → navigation-Bot0hvuv.js} +1 -1
package/static/app/assets/{network-pYQt5oBu.js → network-jE42eKfT.js} +1 -1
package/static/app/assets/{primitives-D7gCdEvS.js → primitives-CX2Komon.js} +1 -1
package/static/app/assets/{shield-alert-K9RKGQeg.js → shield-alert-BftATuAA.js} +1 -1
package/static/app/assets/{textarea-sqQmoBKL.js → textarea-CiMJfOSI.js} +1 -1
package/static/app/assets/{useFocusTrap-7EV9dFP2.js → useFocusTrap-B7RPGfFy.js} +1 -1
package/static/app/assets/utils-SJUNVOj5.js +7 -0
package/static/app/index.html +4 -4
package/static/sw.js +1 -1
package/static/app/assets/Act-DmdruVKV.js +0 -1
package/static/app/assets/BrainHome-CeNaxjP1.js +0 -2
package/static/app/assets/BrainSignals-CStjIqYi.js +0 -1
package/static/app/assets/utils-uQYKXNeq.js +0 -7

package/latticeai/core/file_generation.py CHANGED Viewed

@@ -358,6 +358,23 @@ _BUNDLE_HTML_RULE = (
     "blocks, no inline behavior scripts."
 )
+# Vite/React bundles need a module entry point, not classic script tags.
+_BUNDLE_HTML_MODULE_RULE = (
+    "Produce ONE complete HTML5 document: <!DOCTYPE html>, <html>, <head> with "
+    "<meta charset=\"utf-8\"> and a <title>, and a closed </html> tag. "
+    "This page is the Vite entry of a React project: the <body> must contain "
+    "<div id=\"root\"></div> and load the app with "
+    "<script type=\"module\" src=\"/src/main.jsx\"></script> just before "
+    "</body>. No inline <style> blocks, no other scripts, no external files."
+)
+def _bundle_html_rule(bundle_files: List[str]) -> str:
+    """Pick the HTML bundle rule that matches the bundle's technology."""
+    if any(str(path).lower().endswith((".jsx", ".tsx")) for path in bundle_files):
+        return _BUNDLE_HTML_MODULE_RULE
+    return _BUNDLE_HTML_RULE
 def build_file_generation_context(
     target_path: str,
@@ -381,7 +398,7 @@ def build_file_generation_context(
     ]
     type_rule = _TYPE_RULES.get(ext)
     if bundle_files and ext in (".html", ".htm"):
-        type_rule = _BUNDLE_HTML_RULE
+        type_rule = _bundle_html_rule(bundle_files)
     if type_rule:
         parts.append(f"- {type_rule}")
     if bundle_files:
@@ -608,16 +625,116 @@ _EXPLICIT_FILENAME_RE = re.compile(
     re.IGNORECASE,
 )
 _PROJECT_NAME_RE = re.compile(r"([A-Za-z][A-Za-z0-9_-]{1,30})\s*(?:앱|app\b)", re.IGNORECASE)
+# React/Vite intent: the react keyword is specific enough on its own.
+_REACT_HINT_RE = re.compile(r"(?<![a-z0-9])react(?![a-z0-9])|리액트")
+_VITE_HINT_RE = re.compile(r"(?<![a-z0-9])vite(?![a-z0-9])")
+# Python package intent: language + package word, both required.
+_PYTHON_HINT_RE = re.compile(r"(?<![a-z0-9])python(?![a-z0-9])|파이썬")
+_PACKAGE_HINT_RE = re.compile(r"패키지|(?<![a-z0-9])package(?![a-z0-9])")
+_PKG_NAME_RE = re.compile(
+    r"([A-Za-z][A-Za-z0-9_-]{1,30})\s*(?:패키지|package\b)", re.IGNORECASE
+)
+def _react_manifest(text: str) -> Dict[str, Any]:
+    """Vite + React starter manifest (review Wave 4: manifest 확장)."""
+    name_match = _PROJECT_NAME_RE.search(text)
+    name = f"{name_match.group(1).lower()}-app" if name_match else "react-app"
+    return {
+        "name": name,
+        "kind": "react",
+        "files": [
+            {
+                "path": "package.json",
+                "brief": (
+                    f'Vite React app manifest: strictly valid JSON with "name": "{name}", '
+                    '"private": true, "type": "module", "scripts" {"dev": "vite", '
+                    '"build": "vite build", "preview": "vite preview"}, "dependencies" '
+                    'with react and react-dom (^18), and "devDependencies" with vite '
+                    "and @vitejs/plugin-react."
+                ),
+            },
+            {
+                "path": "index.html",
+                "brief": (
+                    "The Vite entry HTML: <div id=\"root\"></div> in <body> and "
+                    "<script type=\"module\" src=\"/src/main.jsx\"></script> just "
+                    "before </body>. No inline styles or scripts."
+                ),
+            },
+            {
+                "path": "src/main.jsx",
+                "brief": (
+                    "React entry: createRoot from react-dom/client rendering <App /> "
+                    "into #root; imports ./App.jsx and ./App.css."
+                ),
+            },
+            {
+                "path": "src/App.jsx",
+                "brief": (
+                    "The main App component implementing the user's request as one "
+                    "self-contained React component (hooks allowed, no extra deps)."
+                ),
+            },
+            {
+                "path": "src/App.css",
+                "brief": "All visual styles for the App component.",
+            },
+        ],
+    }
+def _python_package_manifest(text: str) -> Dict[str, Any]:
+    """Multi-file Python package manifest (review Wave 4: manifest 확장)."""
+    name_match = _PKG_NAME_RE.search(text)
+    raw_name = name_match.group(1).lower() if name_match else "my_package"
+    module = re.sub(r"[^a-z0-9_]", "_", raw_name)
+    if not re.match(r"[a-z_]", module):
+        module = f"pkg_{module}"
+    return {
+        "name": module,
+        "kind": "python",
+        "files": [
+            {
+                "path": f"{module}/__init__.py",
+                "brief": (
+                    f"Package init for {module}: import and re-export the public "
+                    "API from .core with an explicit __all__."
+                ),
+            },
+            {
+                "path": f"{module}/core.py",
+                "brief": (
+                    "Implement the user's request as clean, documented functions/"
+                    "classes with type hints. Standard library only."
+                ),
+            },
+            {
+                "path": f"{module}/cli.py",
+                "brief": (
+                    "argparse CLI wrapping the core API: a main() function and an "
+                    'if __name__ == "__main__": main() guard.'
+                ),
+            },
+            {
+                "path": "README.md",
+                "brief": (
+                    f"Usage documentation for the {module} package: install, import "
+                    "example, and CLI example."
+                ),
+            },
+        ],
+    }
 def infer_project_manifest(message: str) -> Optional[Dict[str, Any]]:
-    """Infer a multi-file web-project manifest from a creation request.
+    """Infer a multi-file project manifest from a creation request.
     "todo 앱 html+css+js로 만들어줘" should yield real linked files, not one
     inlined page. Deliberately narrow and deterministic (weak local models
-    never see this decision): requires a creation verb, an HTML-page intent,
-    at least one *additional* named technology (css/js), and no explicit
-    filename. Single-type requests return ``None`` so the existing
+    never see this decision): requires a creation verb, a recognized project
+    intent (web page + css/js, React/Vite app, or Python package), and no
+    explicit filename. Single-type requests return ``None`` so the existing
     single-file flow is completely unchanged.
     """
     text = (message or "").strip()
@@ -626,6 +743,14 @@ def infer_project_manifest(message: str) -> Optional[Dict[str, Any]]:
     if _EXPLICIT_FILENAME_RE.search(text):
         return None
     lower = text.lower()
+    # Most-specific first: React (its own structure), then Python package,
+    # then the classic html+css/js web bundle.
+    if _REACT_HINT_RE.search(lower) or _VITE_HINT_RE.search(lower):
+        return _react_manifest(text)
+    if _PYTHON_HINT_RE.search(lower) and _PACKAGE_HINT_RE.search(lower):
+        return _python_package_manifest(text)
     wants_html = bool(_HTML_HINT_RE.search(lower))
     wants_css = bool(_CSS_HINT_RE.search(lower))
     wants_js = bool(_JS_HINT_RE.search(lower))

package/latticeai/core/legacy_compatibility.py CHANGED Viewed

@@ -14,7 +14,7 @@ from pathlib import Path
 from typing import Any, Dict, List
-LEGACY_COMPATIBILITY_VERSION = "9.9.3"
+LEGACY_COMPATIBILITY_VERSION = "9.9.4"
 @dataclass(frozen=True)

package/latticeai/core/marketplace.py CHANGED Viewed

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

package/latticeai/core/run_store.py ADDED Viewed

@@ -0,0 +1,243 @@
+"""Durable persistence for paused agent runs (review 2026-07-25 Wave 0.1).
+The ``awaiting_approval`` loop parked runs in an in-process dict, so a server
+restart between pause and resume turned every outstanding approval into a 404
+("승인하려다 사라짐"). This store writes each paused run to one JSON file under
+the data dir, so a valid, unexpired token can resume its run across restarts
+and across worker processes.
+Design constraints (deliberate, matching :mod:`latticeai.services.funnel_metrics`):
+* **One JSON file per run**, atomic replace on write — no new dependencies.
+* **Fail-open on save, fail-closed on resume.** A persistence error never
+  breaks the pause response (the in-memory path still works); a load error on
+  resume is treated as "run not found".
+* **Tokens are never stored in plaintext.** Only the SHA-256 hex digest is
+  persisted; resume hashes the presented token and compares digests.
+* **Wall-clock expiry.** The in-memory dict keeps its monotonic deadline, but
+  monotonic time does not survive a restart — the durable record carries an
+  absolute UTC epoch and files past it are swept, never resumed.
+"""
+from __future__ import annotations
+import hashlib
+import json
+import logging
+import os
+import re
+import tempfile
+import time
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+from latticeai.core.agent import AgentRunContext, AgentState
+from latticeai.core.agent_trace import LoopTrace
+LOGGER = logging.getLogger(__name__)
+# run_id comes from ``secrets.token_urlsafe`` — validate before any path use
+# so a crafted id can never traverse out of the store directory.
+_RUN_ID_RE = re.compile(r"^[A-Za-z0-9_-]{8,64}$")
+def hash_approval_token(token: str) -> str:
+    """Stable digest used both at save and at resume comparison time."""
+    return hashlib.sha256(str(token or "").encode("utf-8")).hexdigest()
+def serialize_run_context(ctx: AgentRunContext) -> Dict[str, Any]:
+    """Reduce an :class:`AgentRunContext` to plain JSON-safe data."""
+    return {
+        "state": ctx.state.value,
+        "plan": ctx.plan,
+        "transcript": ctx.transcript,
+        "retry_count": ctx.retry_count,
+        "state_history": ctx.state_history,
+        "corrections": ctx.corrections,
+        "final_message": ctx.final_message,
+        "rollback_log": ctx.rollback_log,
+        "executing_model": ctx.executing_model,
+        "reviewing_model": ctx.reviewing_model,
+        "approved_by_human": ctx.approved_by_human,
+        "trace": {"events": ctx.trace.events, "truncated": ctx.trace.truncated},
+    }
+def restore_run_context(payload: Dict[str, Any]) -> AgentRunContext:
+    """Rebuild an :class:`AgentRunContext` from :func:`serialize_run_context`."""
+    ctx = AgentRunContext()
+    try:
+        ctx.state = AgentState(str(payload.get("state") or AgentState.WAITING_APPROVAL.value))
+    except ValueError:
+        ctx.state = AgentState.WAITING_APPROVAL
+    ctx.plan = dict(payload.get("plan") or {})
+    ctx.transcript = list(payload.get("transcript") or [])
+    ctx.retry_count = int(payload.get("retry_count") or 0)
+    ctx.state_history = list(payload.get("state_history") or [])
+    ctx.corrections = list(payload.get("corrections") or [])
+    ctx.final_message = str(payload.get("final_message") or "")
+    ctx.rollback_log = list(payload.get("rollback_log") or [])
+    ctx.executing_model = payload.get("executing_model")
+    ctx.reviewing_model = payload.get("reviewing_model")
+    ctx.approved_by_human = bool(payload.get("approved_by_human"))
+    trace_payload = payload.get("trace") or {}
+    trace = LoopTrace()
+    trace.events = list(trace_payload.get("events") or [])
+    trace.truncated = int(trace_payload.get("truncated") or 0)
+    ctx.trace = trace
+    return ctx
+class AgentRunStore:
+    """One-JSON-file-per-run persistence for paused approval runs."""
+    def __init__(self, root: Path) -> None:
+        self._root = Path(root)
+    def _path_for(self, run_id: str) -> Optional[Path]:
+        if not _RUN_ID_RE.fullmatch(str(run_id or "")):
+            return None
+        return self._root / f"{run_id}.json"
+    # ── writes ───────────────────────────────────────────────────────────
+    def save(
+        self,
+        run_id: str,
+        *,
+        ctx: AgentRunContext,
+        req_payload: Dict[str, Any],
+        language_hint: str,
+        user: str,
+        token: str,
+        expires_epoch: float,
+        expires_at: str,
+    ) -> bool:
+        """Persist a paused run. Best-effort: returns False on any failure."""
+        path = self._path_for(run_id)
+        if path is None:
+            return False
+        record = {
+            "version": 1,
+            "run_id": run_id,
+            "user": user,
+            "language_hint": language_hint,
+            "token_hash": hash_approval_token(token),
+            "expires_epoch": float(expires_epoch),
+            "expires_at": expires_at,
+            "req": req_payload,
+            "ctx": serialize_run_context(ctx),
+        }
+        try:
+            self._root.mkdir(parents=True, exist_ok=True)
+            fd, tmp_name = tempfile.mkstemp(prefix=path.name, dir=str(self._root))
+            try:
+                with os.fdopen(fd, "w", encoding="utf-8") as handle:
+                    json.dump(record, handle, ensure_ascii=False)
+                os.replace(tmp_name, path)
+            finally:
+                if os.path.exists(tmp_name):
+                    try:
+                        os.unlink(tmp_name)
+                    except OSError:
+                        pass
+            return True
+        except Exception as exc:  # noqa: BLE001 — pause must still answer without disk
+            LOGGER.warning("agent run store save failed for %s: %s", run_id, exc)
+            return False
+    def delete(self, run_id: str) -> None:
+        path = self._path_for(run_id)
+        if path is None:
+            return
+        try:
+            path.unlink(missing_ok=True)
+        except OSError as exc:
+            LOGGER.warning("agent run store delete failed for %s: %s", run_id, exc)
+    # ── reads ────────────────────────────────────────────────────────────
+    def load(self, run_id: str) -> Optional[Dict[str, Any]]:
+        """Raw persisted record, or None when missing/corrupt/invalid id."""
+        path = self._path_for(run_id)
+        if path is None:
+            return None
+        try:
+            record = json.loads(path.read_text(encoding="utf-8"))
+        except FileNotFoundError:
+            return None
+        except Exception as exc:  # noqa: BLE001 — corrupt record == not found
+            LOGGER.warning("agent run store load failed for %s: %s", run_id, exc)
+            return None
+        if not isinstance(record, dict) or record.get("run_id") != run_id:
+            return None
+        return record
+    def pending_summaries(self, user: Optional[str] = None) -> List[Dict[str, Any]]:
+        """Unexpired pending runs (optionally per user) for surfacing in UI."""
+        summaries: List[Dict[str, Any]] = []
+        now = time.time()
+        try:
+            paths = sorted(self._root.glob("*.json"))
+        except OSError:
+            return summaries
+        for path in paths:
+            try:
+                record = json.loads(path.read_text(encoding="utf-8"))
+            except Exception:  # noqa: BLE001
+                continue
+            if not isinstance(record, dict):
+                continue
+            if float(record.get("expires_epoch") or 0) <= now:
+                continue
+            if user is not None and record.get("user") != user:
+                continue
+            plan = (record.get("ctx") or {}).get("plan") or {}
+            summaries.append({
+                "run_id": record.get("run_id"),
+                "user": record.get("user"),
+                "goal": str(plan.get("goal") or "")[:200],
+                "expires_at": record.get("expires_at"),
+            })
+        return summaries
+    def sweep_expired(
+        self,
+        now_epoch: Optional[float] = None,
+        *,
+        retention_seconds: float = 86400.0,
+    ) -> int:
+        """Remove long-expired run files; returns how many were removed.
+        Recently expired records are *kept* for ``retention_seconds`` so that
+        a resume attempt after expiry can still answer 410 with a one-click
+        replan hint (the original request message) instead of a bare 404.
+        """
+        removed = 0
+        now = time.time() if now_epoch is None else float(now_epoch)
+        try:
+            paths = list(self._root.glob("*.json"))
+        except OSError:
+            return removed
+        for path in paths:
+            try:
+                record = json.loads(path.read_text(encoding="utf-8"))
+                expires = float(record.get("expires_epoch") or 0)
+            except Exception:  # noqa: BLE001 — unreadable == expired garbage
+                expires = -float(retention_seconds)
+            if expires + float(retention_seconds) <= now:
+                try:
+                    path.unlink(missing_ok=True)
+                    removed += 1
+                except OSError:
+                    pass
+        return removed
+__all__ = [
+    "AgentRunStore",
+    "hash_approval_token",
+    "restore_run_context",
+    "serialize_run_context",
+]

package/latticeai/core/workspace_os.py CHANGED Viewed

@@ -49,7 +49,7 @@ __all__ = [
     "remove_skill_directory",
 ]
-WORKSPACE_OS_VERSION = "9.9.3"
+WORKSPACE_OS_VERSION = "9.9.4"
 # Workspace types separate single-user Personal workspaces from shared
 # Organization workspaces. Both keep the same local-first JSON store; the type

package/latticeai/models/router.py CHANGED Viewed

@@ -78,6 +78,27 @@ If context or old chat history mentions those names, treat them only as legacy a
 You are a Vision-Language Model (VLM). If an image is provided, analyze it.
 Be concise and respond in the user's language."""
+# Appended ONLY when retrieved context exists (review 2026-07-25 Wave 2.3):
+# grounded answers should cite their sources and admit gaps. Advisory prompt
+# guidance — grounding assessment stays annotation-only and never blocks.
+CITATION_INSTRUCTION = """The Context section above contains retrieved sources.
+Ground your claims in those sources and cite them inline as [1], [2], ... matching the order they appear in the Context.
+If the context does not cover the question, say so instead of inventing sources.
+Never cite a source that is not in the Context."""
+def _compose_system(base: str, context: str) -> str:
+    """Compose the system prompt with optional retrieved context.
+    Byte-compatible with the historical prompt when ``context`` is empty:
+    the return value is exactly ``base``. When context exists, the Context
+    block plus :data:`CITATION_INSTRUCTION` are appended.
+    """
+    if not context:
+        return base
+    return f"{base}\n\nContext:\n{context}\n\n{CITATION_INSTRUCTION}"
 def normalize_branding(text: Optional[str]) -> str:
     if not text:
         return ""
@@ -497,10 +518,8 @@ class LLMRouter:
         return raw
     def _build_prompt(self, message: str, context: Optional[str], tokenizer) -> str:
-        system = SYSTEM_PROMPT
         context = normalize_branding(context)
-        if context:
-            system += f"\n\nContext:\n{context}"
+        system = _compose_system(SYSTEM_PROMPT, context)
         if hasattr(tokenizer, "apply_chat_template"):
             try:
                 msgs = [{"role": "system", "content": system}, {"role": "user", "content": message}]
@@ -510,10 +529,8 @@ class LLMRouter:
         return f"<|im_start|>system\n{system}<|im_end|>\n<|im_start|>user\n{message}<|im_end|>\n<|im_start|>assistant\n"
     def _build_vlm_prompt(self, model, processor, message: str, context: Optional[str], num_images: int) -> str:
-        system = SYSTEM_PROMPT
         context = normalize_branding(context)
-        if context:
-            system += f"\n\nContext:\n{context}"
+        system = _compose_system(SYSTEM_PROMPT, context)
         try:
             from mlx_vlm import apply_chat_template
@@ -616,10 +633,8 @@ class LLMRouter:
         return normalize_branding(str(result))
     async def _cloud_generate(self, cloud: CloudModel, message: str, context: Optional[str], max_tokens: int, temperature: float) -> str:
-        system = SYSTEM_PROMPT
         context = normalize_branding(context)
-        if context:
-            system += f"\n\nContext:\n{context}"
+        system = _compose_system(SYSTEM_PROMPT, context)
         try:
             response = await cloud.client.chat.completions.create(
                 model=cloud.model,
@@ -703,10 +718,8 @@ class LLMRouter:
             yield chunk
     async def _cloud_stream_generate(self, cloud: CloudModel, message: str, context: Optional[str], max_tokens: int, temperature: float) -> AsyncIterator[str]:
-        system = SYSTEM_PROMPT
         context = normalize_branding(context)
-        if context:
-            system += f"\n\nContext:\n{context}"
+        system = _compose_system(SYSTEM_PROMPT, context)
         try:
             stream = await cloud.client.chat.completions.create(
                 model=cloud.model,

package/latticeai/services/architecture_readiness.py CHANGED Viewed

@@ -17,7 +17,7 @@ from typing import Any, Dict, List
 from latticeai.core.legacy_compatibility import legacy_shim_report
-ARCHITECTURE_VERSION_TARGET = "9.9.3"
+ARCHITECTURE_VERSION_TARGET = "9.9.4"
 PREFERRED_REFACTORING_ORDER = [
     "agent-runtime",

package/latticeai/services/command_center.py CHANGED Viewed

@@ -23,9 +23,10 @@ calls a model.
 from __future__ import annotations
 import logging
+from datetime import datetime, timedelta
 from typing import Any, Dict, List, Optional
-from latticeai.core.timeutil import now_iso as _now
+from latticeai.core.timeutil import local_now, now_iso as _now, parse_iso
 LOGGER = logging.getLogger(__name__)
@@ -33,6 +34,13 @@ _RECENT_NODE_LIMIT = 6
 _SEARCH_HISTORY_LIMIT = 2000
 _BRIEFING_HISTORY_LIMIT = 2000
+# Graph-hygiene advisory (review 2026-07-25 Wave 2.5): once the graph passes
+# this many nodes with no noise-curate pass in the stale window, the briefing
+# suggests a *dry-run* /knowledge-graph/curate/noise. Advisory only — nothing
+# is deleted until the user explicitly applies the job.
+_HYGIENE_MIN_NODES = 200
+_HYGIENE_STALE_DAYS = 7
 def _clip(text: Any, limit: int = 160) -> str:
     value = str(text or "").strip()
@@ -240,6 +248,73 @@ class CommandCenterService:
         ]
         return {"available": True, "count": len(suggestions), "top": top}
+    def _hygiene_section(self) -> Dict[str, Any]:
+        """Advisory graph-hygiene signal (review 2026-07-25 Wave 2.5).
+        Suggests a dry-run noise-curate pass when the graph has grown past
+        ``_HYGIENE_MIN_NODES`` nodes and the last applied pass is missing or
+        older than ``_HYGIENE_STALE_DAYS`` days. Fail-open: any backend error
+        degrades to "no suggestion" — the briefing itself never breaks.
+        """
+        section: Dict[str, Any] = {
+            "available": False,
+            "suggest_noise_curate": False,
+            "reason": "",
+            "last_noise_curate_at": None,
+            "node_count": 0,
+        }
+        if not self._enable_graph or not hasattr(self._kg, "stats"):
+            return section
+        try:
+            stats = self._kg.stats() or {}
+            node_count = sum(
+                int(count or 0) for count in (stats.get("nodes") or {}).values()
+            )
+            last = (
+                self._kg.last_noise_curate_at()
+                if hasattr(self._kg, "last_noise_curate_at")
+                else None
+            )
+            section.update(
+                {
+                    "available": True,
+                    "node_count": node_count,
+                    "last_noise_curate_at": last,
+                }
+            )
+            if node_count < _HYGIENE_MIN_NODES:
+                return section
+            if last is not None and not self._older_than_days(
+                last, _HYGIENE_STALE_DAYS
+            ):
+                return section
+            section["suggest_noise_curate"] = True
+            section["reason"] = (
+                f"{node_count} nodes and no noise curation in the last "
+                f"{_HYGIENE_STALE_DAYS} days"
+                if last
+                else f"{node_count} nodes and no noise curation recorded"
+            )
+        except Exception:
+            LOGGER.exception("command center hygiene read failed")
+            return {
+                "available": False,
+                "suggest_noise_curate": False,
+                "reason": "",
+                "last_noise_curate_at": None,
+                "node_count": 0,
+            }
+        return section
+    @staticmethod
+    def _older_than_days(stamp: str, days: int) -> bool:
+        parsed = parse_iso(stamp)
+        if parsed is None:
+            # Unreadable stamp → treat as stale; suggesting a dry-run is safe.
+            return True
+        now = datetime.now(parsed.tzinfo) if parsed.tzinfo else local_now()
+        return (now - parsed) > timedelta(days=days)
     # ── quick actions ────────────────────────────────────────────────────
     def _quick_actions(self, sections: Dict[str, Dict[str, Any]]) -> List[Dict[str, Any]]:
@@ -295,6 +370,19 @@ class CommandCenterService:
                     "target": "/brain/graph",
                 }
             )
+        hygiene = sections.get("hygiene") or {}
+        if hygiene.get("suggest_noise_curate"):
+            actions.append(
+                {
+                    "id": "curate-noise",
+                    "kind": "hygiene",
+                    "count": int(hygiene.get("node_count") or 0),
+                    "target": "/brain/graph",
+                    # Dry-run by default on the API side: this endpoint only
+                    # *reports* removals until dry_run=false is sent explicitly.
+                    "endpoint": "/knowledge-graph/curate/noise",
+                }
+            )
         if not actions:
             actions.append(
                 {"id": "ask-brain", "kind": "chat", "count": 0, "target": "/brain"}
@@ -319,6 +407,7 @@ class CommandCenterService:
             "suggestions": self._suggestion_section(
                 user_email=user_email, workspace_id=workspace_id
             ),
+            "hygiene": self._hygiene_section(),
         }
         return {
             "generated_at": _now(),

package/latticeai/services/folder_watch.py CHANGED Viewed

@@ -303,6 +303,10 @@ class FolderWatchService:
                 for key in ("status", "new", "changed", "removed", "ingested", "duplicate", "failed")
                 if key in result
             }
+            # Watch trust UI (review Wave 1.3): keep a small sample of the
+            # latest scan's failures so the home health card can show *why*
+            # a watch is unhealthy, not just a count.
+            watch["last_errors"] = list(result.get("errors") or [])[:3]
             if snapshot is not None:
                 watch["snapshot"] = snapshot
             self._save_config()
@@ -353,6 +357,7 @@ class FolderWatchService:
             "created_at": watch.get("created_at"),
             "last_scan_at": watch.get("last_scan_at"),
             "last_result": watch.get("last_result"),
+            "last_errors": list(watch.get("last_errors") or []),
             "tracked_files": len(watch.get("snapshot") or {}),
         }