npm - ltcai - Versions diffs - 9.1.0 → 9.3.0 - Mend

ltcai 9.1.0 → 9.3.0

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 (51) hide show

package/README.md +55 -41
package/docs/CHANGELOG.md +58 -0
package/docs/COMMUNITY_AND_PLUGINS.md +4 -3
package/docs/DEVELOPMENT.md +8 -8
package/docs/LEGACY_COMPATIBILITY.md +1 -1
package/docs/ONBOARDING.md +2 -2
package/docs/OPERATIONS.md +1 -1
package/docs/TRUST_MODEL.md +1 -1
package/docs/WHY_LATTICE.md +1 -1
package/docs/kg-schema.md +1 -1
package/docs/mcp-tools.md +1 -1
package/lattice_brain/__init__.py +1 -1
package/lattice_brain/runtime/multi_agent.py +1 -1
package/latticeai/__init__.py +1 -1
package/latticeai/api/brain_intelligence.py +68 -0
package/latticeai/api/chat_helpers.py +4 -0
package/latticeai/api/chat_intents.py +30 -16
package/latticeai/app_factory.py +4 -0
package/latticeai/core/agent.py +31 -4
package/latticeai/core/agent_prompts.py +5 -0
package/latticeai/core/file_generation.py +451 -0
package/latticeai/core/legacy_compatibility.py +1 -1
package/latticeai/core/marketplace.py +1 -1
package/latticeai/core/workspace_os.py +1 -1
package/latticeai/runtime/chat_wiring.py +2 -0
package/latticeai/runtime/persistence_runtime.py +7 -0
package/latticeai/runtime/router_registration.py +16 -0
package/latticeai/services/architecture_readiness.py +1 -1
package/latticeai/services/brain_intelligence.py +439 -0
package/latticeai/services/memory_service.py +65 -5
package/latticeai/services/product_readiness.py +1 -1
package/latticeai/services/router_context.py +1 -0
package/package.json +1 -1
package/scripts/check_current_release_docs.mjs +1 -1
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 +11 -11
package/static/app/assets/{Act-Bzz0bUyW.js → Act-ls57ctKH.js} +1 -1
package/static/app/assets/{Brain-Dj2J20YA.js → Brain-Jd3V4Obm.js} +1 -1
package/static/app/assets/{Capture-CqlEl1Ga.js → Capture-DLj9Uzed.js} +1 -1
package/static/app/assets/{Library-B03FP1Yx.js → Library-dPbez7Tc.js} +1 -1
package/static/app/assets/{System-80lHW0Ux.js → System-CkROWBuq.js} +1 -1
package/static/app/assets/index-BRUqy2zk.css +2 -0
package/static/app/assets/index-CAlo2Lm-.js +17 -0
package/static/app/assets/{primitives-Q1A96_7v.js → primitives-DrwaJ7dy.js} +1 -1
package/static/app/assets/{textarea-D13RtnTo.js → textarea-DNvCwmmK.js} +1 -1
package/static/app/index.html +2 -2
package/static/sw.js +1 -1
package/static/app/assets/index-BiMofBTM.js +0 -17
package/static/app/assets/index-Bmx9rzTc.css +0 -2

package/latticeai/core/agent.py CHANGED Viewed

@@ -69,9 +69,16 @@ class AgentRunContext:
         self.approved_by_human: bool       = False
+_THINK_BLOCK_RE = re.compile(
+    r"<(think|thinking|reasoning)>.*?</\1>", flags=re.DOTALL | re.IGNORECASE
+)
 def extract_action(raw: str) -> Dict:
     """Parse one JSON action object out of an LLM response (tolerant of fences/prose)."""
-    text = raw.strip()
+    # Small local models often prepend <think>...</think> reasoning that can
+    # itself contain braces — drop it before locating the action object.
+    text = _THINK_BLOCK_RE.sub("", raw).strip()
     fenced = re.search(r"```(?:json)?\s*(\{.*?\})\s*```", text, flags=re.DOTALL)
     if fenced:
         text = fenced.group(1).strip()
@@ -83,8 +90,14 @@ def extract_action(raw: str) -> Dict:
     try:
         action = json.loads(text)
-    except json.JSONDecodeError as exc:
-        raise ValueError(f"Agent did not return valid JSON: {exc}") from exc
+    except json.JSONDecodeError:
+        # Second chance for the most common small-model JSON slips: trailing
+        # commas before a closing brace/bracket.
+        repaired = re.sub(r",\s*([}\]])", r"\1", text)
+        try:
+            action = json.loads(repaired)
+        except json.JSONDecodeError as exc:
+            raise ValueError(f"Agent did not return valid JSON: {exc}") from exc
     if not isinstance(action, dict) or "action" not in action:
         raise ValueError("Agent JSON must include an action field.")
@@ -248,6 +261,7 @@ class SingleAgentRuntime:
         d = self.deps
         exec_count = sum(1 for s in ctx.transcript if s.get("state") == AgentState.EXECUTING.value)
         budget = max(1, max_steps - exec_count)
+        parse_failures = 0
         for _ in range(budget):
             corrections_hint = (
@@ -280,11 +294,24 @@ class SingleAgentRuntime:
             try:
                 action = extract_action(str(raw))
             except ValueError as exc:
+                parse_failures += 1
                 ctx.transcript.append({
                     "state": AgentState.EXECUTING.value, "action": "parse_error",
                     "raw": str(raw)[:400], "error": str(exc),
                 })
-                break
+                if parse_failures >= 3:
+                    break
+                # Weak models often need one concrete reminder of the wire
+                # format; feed it through the corrections channel and retry
+                # instead of aborting the whole run on the first slip.
+                hint = (
+                    'Your last reply was not a single JSON action object. Reply with '
+                    'EXACTLY one JSON object like {"thoughts": "...", "action": '
+                    '"tool_name", "args": {...}} and nothing else.'
+                )
+                if hint not in ctx.corrections:
+                    ctx.corrections.append(hint)
+                continue
             name     = action.get("action")
             thoughts = str(action.get("thoughts") or "")[:600]

package/latticeai/core/agent_prompts.py CHANGED Viewed

@@ -43,6 +43,11 @@ You think and act like a senior software engineer:
 Respond with exactly ONE JSON object per step:
 {"thoughts": "what you learned / why this next action", "action": "tool_name", "args": {...}}
+When writing a file (write_file), args.content must be the COMPLETE raw file
+content: no Markdown fences, no commentary, valid for the file's extension
+(an .html file starts with <!DOCTYPE html> and ends with </html>; a .json
+file must parse as strict JSON).
 When the task is fully done AND a tool result in this run confirms it:
 {"thoughts": "verified", "action": "final", "message": "한국어로 무엇을 했고 어디서 검증했는지 요약"}

package/latticeai/core/file_generation.py ADDED Viewed

@@ -0,0 +1,451 @@
+"""Model-agnostic file content generation pipeline.
+Small local models (gemma/qwen/llama 7B class) asked to "generate an HTML
+file" commonly wrap the payload in chat noise: leading commentary ("Sure!
+Here is your page:"), Markdown fences, ``<think>`` reasoning blocks,
+trailing explanations, or an incomplete document. The previous direct-write
+path saved that reply nearly verbatim, so weak models produced broken files.
+This module makes the file-creation flow robust regardless of which LLM is
+loaded, by treating the model as an untrusted content source:
+1. Prompt   — extension-aware instructions anchored with the exact first
+   line the reply must start with (small models follow examples, not rules).
+2. Extract  — strip reasoning blocks and conversational framing, pick the
+   best fenced block, slice known document boundaries.
+3. Validate — per-extension structural checks (HTML document shape, JSON
+   parses, CSS has rule blocks, refusal/chat detection).
+4. Retry    — one corrective attempt that tells the model what was wrong.
+5. Repair   — deterministic scaffolds guarantee the user still gets a valid
+   file even when the model never produces usable output.
+The pipeline is pure (no I/O, no FastAPI); the chat layer injects an async
+``generate(context) -> str`` callable.
+"""
+from __future__ import annotations
+import html as html_lib
+import json
+import re
+from typing import Any, Awaitable, Callable, Dict, List, Optional, Tuple
+# ── extraction ──────────────────────────────────────────────────────────
+_THINK_BLOCK_RE = re.compile(
+    r"<(think|thinking|reasoning|reflection)>.*?</\1>",
+    re.DOTALL | re.IGNORECASE,
+)
+# Unclosed think block (model hit the token limit mid-reasoning).
+_THINK_OPEN_RE = re.compile(r"<(think|thinking|reasoning)>.*\Z", re.DOTALL | re.IGNORECASE)
+_FENCE_RE = re.compile(r"```([\w.+-]*)[ \t]*\n(.*?)```", re.DOTALL)
+# Conversational lines that small models prepend/append around the payload.
+_CHAT_LINE_RE = re.compile(
+    r"^\s*("
+    r"(sure|of course|certainly|okay|ok|alright|great|absolutely)\b[^\n]*"
+    r"|here('s| is| are)\b[^\n]*"
+    r"|i('ve| have) (created|written|generated|made)\b[^\n]*"
+    r"|(below|following) is\b[^\n]*"
+    r"|let me know\b[^\n]*"
+    r"|hope (this|that) helps[^\n]*"
+    r"|feel free\b[^\n]*"
+    r"|물론(입니다|이죠|이에요)?[!., ]*[^\n]*"
+    r"|네[,!. ][^\n]*"
+    r"|알겠습니다[^\n]*"
+    r"|다음은[^\n]*(입니다|합니다)[:.]?[^\n]*"
+    r"|아래는?[^\n]*(입니다|내용)[^\n]*"
+    r"|(요청하신|원하시는)[^\n]*(입니다|만들었습니다|작성했습니다)[^\n]*"
+    r"|(파일|내용|코드)[을를]?\s*(생성|작성|만들)[^\n]*"
+    r"|도움이 (필요하|되)[^\n]*"
+    r"|추가로[^\n]*(말씀|요청)[^\n]*"
+    r")\s*$",
+    re.IGNORECASE,
+)
+_REFUSAL_RE = re.compile(
+    r"(i can('|no)?t|i'?m (sorry|unable)|as an ai|cannot assist"
+    r"|죄송(하지만|합니다)|할 수 없|불가능합니다|도와드릴 수 없)",
+    re.IGNORECASE,
+)
+# Language tags that identify a fenced block as the payload for an extension.
+_EXT_FENCE_LANGS: Dict[str, Tuple[str, ...]] = {
+    ".html": ("html", "htm", "xhtml"),
+    ".htm": ("html", "htm", "xhtml"),
+    ".css": ("css",),
+    ".js": ("js", "javascript"),
+    ".jsx": ("jsx", "javascript"),
+    ".ts": ("ts", "typescript"),
+    ".tsx": ("tsx", "typescript"),
+    ".py": ("py", "python"),
+    ".json": ("json",),
+    ".yaml": ("yaml", "yml"),
+    ".yml": ("yaml", "yml"),
+    ".toml": ("toml",),
+    ".md": ("md", "markdown"),
+    ".markdown": ("md", "markdown"),
+    ".sql": ("sql",),
+    ".sh": ("sh", "bash", "shell", "zsh"),
+    ".xml": ("xml", "svg"),
+    ".csv": ("csv",),
+    ".txt": ("txt", "text", "plaintext"),
+}
+def _ext(path: str) -> str:
+    dot = path.rfind(".")
+    return path[dot:].lower() if dot >= 0 else ""
+def _strip_chat_lines(text: str) -> str:
+    """Drop leading/trailing conversational lines around the payload."""
+    lines = text.split("\n")
+    start, end = 0, len(lines)
+    while start < end and (not lines[start].strip() or _CHAT_LINE_RE.match(lines[start])):
+        start += 1
+    while end > start and (not lines[end - 1].strip() or _CHAT_LINE_RE.match(lines[end - 1])):
+        end -= 1
+    stripped = "\n".join(lines[start:end]).strip()
+    return stripped if stripped else text.strip()
+def extract_file_content(raw: str, target_path: str) -> str:
+    """Recover the intended file payload from an arbitrary model reply."""
+    text = (raw or "").strip()
+    if not text:
+        return ""
+    text = _THINK_BLOCK_RE.sub("", text)
+    text = _THINK_OPEN_RE.sub("", text).strip()
+    ext = _ext(target_path)
+    fences = _FENCE_RE.findall(text + ("\n```" if text.count("```") % 2 else ""))
+    if fences:
+        wanted = _EXT_FENCE_LANGS.get(ext, ())
+        matching = [body for lang, body in fences if lang.lower() in wanted]
+        candidates = matching if matching else [body for _, body in fences]
+        # The payload is the largest block; short blocks are usually usage
+        # snippets ("run it with: python app.py").
+        content = max(candidates, key=len).strip()
+    else:
+        content = _strip_chat_lines(text)
+    if ext in (".html", ".htm"):
+        content = _slice_html_document(content)
+    elif ext == ".json":
+        sliced = _slice_json_document(content)
+        if sliced is not None:
+            content = sliced
+    return content.strip()
+def _slice_html_document(content: str) -> str:
+    """Cut a complete HTML document out of surrounding prose when present."""
+    lower = content.lower()
+    start = lower.find("<!doctype")
+    if start < 0:
+        start = lower.find("<html")
+    if start > 0:
+        content = content[start:]
+        lower = lower[start:]
+    end = lower.rfind("</html>")
+    if end >= 0:
+        content = content[: end + len("</html>")]
+    return content
+def _slice_json_document(content: str) -> Optional[str]:
+    """Return the largest parseable JSON value inside ``content``, if any."""
+    candidates: List[str] = [content]
+    for opener, closer in (("{", "}"), ("[", "]")):
+        start = content.find(opener)
+        end = content.rfind(closer)
+        if start >= 0 and end > start:
+            candidates.append(content[start : end + 1])
+    best: Optional[str] = None
+    for candidate in candidates:
+        try:
+            json.loads(candidate)
+        except (ValueError, TypeError):
+            continue
+        if best is None or len(candidate) > len(best):
+            best = candidate
+    return best
+# ── validation ──────────────────────────────────────────────────────────
+def looks_like_refusal(content: str) -> bool:
+    head = content[:300]
+    return bool(_REFUSAL_RE.search(head)) and len(content) < 600
+def validate_file_content(content: str, target_path: str) -> Tuple[bool, str]:
+    """Structural sanity check per file type. Returns (ok, reason)."""
+    if not content.strip():
+        return False, "empty output"
+    if looks_like_refusal(content):
+        return False, "the reply was a refusal/chat message, not file content"
+    ext = _ext(target_path)
+    if ext in (".html", ".htm"):
+        lower = content.lower()
+        if "<html" not in lower and "<!doctype" not in lower:
+            return False, "not a complete HTML document (missing <!DOCTYPE html>/<html>)"
+        if "</html>" not in lower:
+            return False, "HTML document is truncated (missing </html>)"
+        return True, "ok"
+    if ext == ".json":
+        try:
+            json.loads(content)
+        except (ValueError, TypeError) as exc:
+            return False, f"invalid JSON: {exc}"
+        return True, "ok"
+    if ext == ".css":
+        if "{" not in content or "}" not in content:
+            return False, "no CSS rule blocks found"
+        return True, "ok"
+    if ext in (".py", ".js", ".jsx", ".ts", ".tsx", ".sh", ".sql"):
+        if "```" in content:
+            return False, "output still contains Markdown fences"
+        return True, "ok"
+    return True, "ok"
+# ── prompting ───────────────────────────────────────────────────────────
+_FIRST_LINE_HINTS: Dict[str, str] = {
+    ".html": "<!DOCTYPE html>",
+    ".htm": "<!DOCTYPE html>",
+    ".py": "# (python code — imports or code on the first line)",
+    ".sh": "#!/bin/sh",
+    ".json": "{",
+    ".xml": "<?xml version=\"1.0\" encoding=\"UTF-8\"?>",
+}
+_TYPE_RULES: Dict[str, str] = {
+    ".html": (
+        "Produce ONE complete standalone HTML5 document: <!DOCTYPE html>, <html>, "
+        "<head> with <meta charset=\"utf-8\"> and a <title>, inline <style> for CSS, "
+        "and a closed </html> tag. Do not reference external files."
+    ),
+    ".htm": (
+        "Produce ONE complete standalone HTML5 document ending with </html>."
+    ),
+    ".json": "Produce strictly valid JSON (double quotes, no comments, no trailing commas).",
+    ".css": "Produce valid CSS rules only.",
+    ".md": "Produce well-structured Markdown with headings.",
+    ".markdown": "Produce well-structured Markdown with headings.",
+    ".csv": "Produce CSV with a header row; comma-separated, one record per line.",
+    ".py": "Produce complete runnable Python source code.",
+    ".js": "Produce complete valid JavaScript source code.",
+}
+def build_file_generation_context(
+    target_path: str,
+    user_request: str,
+    feedback: Optional[str] = None,
+) -> str:
+    """Strict, extension-aware generation instructions.
+    Small models ignore abstract rules but reliably imitate concrete anchors,
+    so the prompt pins the exact first line of the expected output.
+    """
+    ext = _ext(target_path)
+    parts = [
+        "You are a file content generator. Your entire reply is saved verbatim "
+        f"as the file `{target_path}` — it is NOT shown in a chat.",
+        "Rules:",
+        "- Output ONLY the raw file content.",
+        "- No Markdown code fences (```), no explanations, no greetings, "
+        "no text before or after the content.",
+    ]
+    type_rule = _TYPE_RULES.get(ext)
+    if type_rule:
+        parts.append(f"- {type_rule}")
+    first_line = _FIRST_LINE_HINTS.get(ext)
+    if first_line:
+        parts.append(f"- The very first line of your reply must be: {first_line}")
+    if feedback:
+        parts.append(
+            "Your previous attempt was rejected: "
+            f"{feedback}. Fix that and output only the corrected file content."
+        )
+    parts.append(f"\nUser request: {user_request}")
+    return "\n".join(parts)
+# ── repair (deterministic fallback) ─────────────────────────────────────
+def repair_file_content(content: str, target_path: str, user_request: str) -> str:
+    """Turn whatever the model produced into a valid file of the target type.
+    This is the last resort after retries: the user asked for a file, so the
+    request must still end in a well-formed file, never an error.
+    """
+    ext = _ext(target_path)
+    salvage = content.strip()
+    if looks_like_refusal(salvage):
+        salvage = ""
+    if ext in (".html", ".htm"):
+        return _repair_html(salvage, user_request)
+    if ext == ".json":
+        sliced = _slice_json_document(salvage)
+        if sliced is not None:
+            return sliced
+        return json.dumps(
+            {"request": user_request, "content": salvage},
+            ensure_ascii=False,
+            indent=2,
+        )
+    if salvage:
+        return salvage
+    # Nothing usable at all — leave an honest placeholder in the right format.
+    comment = {
+        ".py": "# TODO: model produced no usable content for: ",
+        ".js": "// TODO: model produced no usable content for: ",
+        ".css": "/* TODO: model produced no usable content for: ",
+        ".sh": "# TODO: model produced no usable content for: ",
+        ".sql": "-- TODO: model produced no usable content for: ",
+    }.get(ext, "")
+    if ext == ".css":
+        return f"{comment}{user_request} */\n"
+    if comment:
+        return f"{comment}{user_request}\n"
+    return f"{user_request}\n"
+def _repair_html(salvage: str, user_request: str) -> str:
+    lower = salvage.lower()
+    if "<html" in lower or "<!doctype" in lower:
+        # A real document that is merely truncated — close it.
+        doc = _slice_html_document(salvage)
+        low = doc.lower()
+        if "</body>" not in low and "<body" in low:
+            doc += "\n</body>"
+        if "</html>" not in low:
+            doc += "\n</html>"
+        return doc
+    if re.search(r"<\w+[^>]*>", salvage):
+        body = salvage  # an HTML fragment — embed as-is
+    elif salvage:
+        body = "\n".join(
+            f"  <p>{html_lib.escape(line)}</p>"
+            for line in salvage.splitlines()
+            if line.strip()
+        )
+    else:
+        body = f"  <p>{html_lib.escape(user_request)}</p>"
+    title = html_lib.escape(user_request[:60] or "Generated page")
+    return (
+        "<!DOCTYPE html>\n"
+        "<html lang=\"ko\">\n"
+        "<head>\n"
+        "  <meta charset=\"utf-8\">\n"
+        "  <meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">\n"
+        f"  <title>{title}</title>\n"
+        "  <style>\n"
+        "    body { font-family: system-ui, sans-serif; margin: 2rem auto; "
+        "max-width: 720px; line-height: 1.6; padding: 0 1rem; }\n"
+        "  </style>\n"
+        "</head>\n"
+        "<body>\n"
+        f"{body}\n"
+        "</body>\n"
+        "</html>"
+    )
+# ── filename inference ──────────────────────────────────────────────────
+_CREATE_VERB_RE = re.compile(
+    r"(만들|생성|작성|써\s*줘|저장|create|make|write|generate|build|save)",
+    re.IGNORECASE,
+)
+# Explicit type keyword → default filename. Ordered: first match wins.
+_TYPE_KEYWORDS: Tuple[Tuple[str, str], ...] = (
+    (r"\bhtml\b|웹\s*페이지|웹페이지|홈페이지|landing\s*page|web\s*page", "generated_page.html"),
+    (r"\bcss\b|스타일\s*시트", "styles.css"),
+    (r"\bjavascript\b|\bjs\b\s*(파일|file)|자바스크립트", "script.js"),
+    (r"\bpython\b|파이썬", "script.py"),
+    (r"\bjson\b", "data.json"),
+    (r"\bcsv\b", "data.csv"),
+    (r"\byaml\b|\byml\b", "config.yaml"),
+    (r"\bxml\b", "data.xml"),
+    (r"\bsql\b", "query.sql"),
+    (r"마크다운|\bmarkdown\b|\bmd\b\s*(파일|file)", "notes.md"),
+    (r"텍스트\s*파일|\btext\s*file\b|\btxt\b", "notes.txt"),
+)
+def infer_file_target(message: str) -> Optional[str]:
+    """Infer a filename for creation requests that name a type but no path.
+    "html 파일 만들어줘" previously fell through to the agent JSON loop, which
+    small models fail at. Inference keeps such requests on the deterministic
+    direct-write path. Deliberately narrow: requires a creation verb and an
+    explicit file-type keyword — report/document prose requests keep flowing
+    to the document generator.
+    """
+    text = (message or "").strip()
+    if not text or not _CREATE_VERB_RE.search(text):
+        return None
+    lower = text.lower()
+    for pattern, filename in _TYPE_KEYWORDS:
+        if re.search(pattern, lower):
+            return filename
+    return None
+# ── orchestration ───────────────────────────────────────────────────────
+async def generate_file_content(
+    generate: Callable[[str], Awaitable[Any]],
+    *,
+    target_path: str,
+    user_request: str,
+    max_attempts: int = 2,
+) -> Tuple[str, Dict[str, Any]]:
+    """Generate validated file content with any LLM.
+    ``generate`` is an async callable ``context -> raw model text``. Runs up
+    to ``max_attempts`` model calls (the second with corrective feedback),
+    then falls back to deterministic repair, so the returned content is
+    always non-empty and structurally valid for the target type.
+    """
+    attempts: List[Dict[str, Any]] = []
+    feedback: Optional[str] = None
+    last_candidate = ""
+    for attempt in range(1, max_attempts + 1):
+        context = build_file_generation_context(target_path, user_request, feedback=feedback)
+        try:
+            raw = await generate(context)
+        except Exception as exc:  # model backend hiccup — repair still delivers
+            attempts.append({"attempt": attempt, "valid": False, "reason": f"generation error: {exc}"})
+            feedback = "the model call failed"
+            continue
+        candidate = extract_file_content(str(raw or ""), target_path)
+        ok, reason = validate_file_content(candidate, target_path)
+        attempts.append({"attempt": attempt, "valid": ok, "reason": reason})
+        if ok:
+            return candidate, {"attempts": attempts, "repaired": False}
+        if len(candidate) > len(last_candidate):
+            last_candidate = candidate
+        feedback = reason
+    repaired = repair_file_content(last_candidate, target_path, user_request)
+    return repaired, {"attempts": attempts, "repaired": True}
+__all__ = [
+    "build_file_generation_context",
+    "extract_file_content",
+    "generate_file_content",
+    "infer_file_target",
+    "looks_like_refusal",
+    "repair_file_content",
+    "validate_file_content",
+]

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.1.0"
+LEGACY_COMPATIBILITY_VERSION = "9.3.0"
 @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.1.0"
+MARKETPLACE_VERSION = "9.3.0"
 TEMPLATE_KINDS = ("plugin", "workflow", "agent", "ingestion_bridge")

package/latticeai/core/workspace_os.py CHANGED Viewed

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

package/latticeai/runtime/chat_wiring.py CHANGED Viewed

@@ -65,6 +65,7 @@ def build_interaction_contexts(
     memory_service: Any,
     platform: Any,
     active_model_getter: Any = None,
+    brain_intelligence: Any = None,
 ) -> tuple[ToolRouterContext, InteractionRouterContext]:
     tool_router_context = ToolRouterContext(
         config=config,
@@ -105,6 +106,7 @@ def build_interaction_contexts(
         memory_service=memory_service,
         platform=platform,
         active_model_getter=active_model_getter,
+        brain_intelligence=brain_intelligence,
     )
     return tool_router_context, interaction_router_context

package/latticeai/runtime/persistence_runtime.py CHANGED Viewed

@@ -36,6 +36,7 @@ def build_persistence_runtime(
     from latticeai.core.plugins import PluginRegistry
     from latticeai.core.realtime import RealtimeBus
     from latticeai.core.workspace_os import WorkspaceOSStore
+    from latticeai.services.brain_intelligence import BrainIntelligenceService
     from latticeai.services.memory_service import MemoryService
     from latticeai.services.workspace_service import WorkspaceService
@@ -57,6 +58,11 @@ def build_persistence_runtime(
         history_file=history_file,
         conversation_store=conversations,
     )
+    brain_intelligence = BrainIntelligenceService(
+        knowledge_graph=knowledge_graph,
+        memory_service=memory_service,
+        enable_graph=enable_graph,
+    )
     ingestion_pipeline = IngestionPipeline(
         knowledge_graph,
         hooks=hooks_registry,
@@ -81,6 +87,7 @@ def build_persistence_runtime(
         "TEMPLATE_CATALOG": template_catalog,
         "AGENT_REGISTRY": agent_registry,
         "MEMORY_SERVICE": memory_service,
+        "BRAIN_INTELLIGENCE": brain_intelligence,
         "INGESTION_PIPELINE": ingestion_pipeline,
         "DEVICE_IDENTITY": device_identity,
         "KG_PORTABILITY": kg_portability,

package/latticeai/runtime/router_registration.py CHANGED Viewed

@@ -485,6 +485,8 @@ def register_interaction_routers(
     memory_service: Any = None,
     platform: Any = None,
     active_model_getter: Any = None,
+    create_brain_intelligence_router: Any = None,
+    brain_intelligence: Any = None,
 ) -> tuple[Any, ...]:
     """Register chat/search/tools/hooks/registry/memory routes in order."""
@@ -504,6 +506,7 @@ def register_interaction_routers(
         memory_service = interaction_context.memory_service
         platform = interaction_context.platform
         active_model_getter = interaction_context.active_model_getter
+        brain_intelligence = interaction_context.brain_intelligence
     return register_routers(
         app,
@@ -561,6 +564,19 @@ def register_interaction_routers(
             append_audit_event=append_audit_event,
             active_model_getter=active_model_getter,
         ),
+        *(
+            (
+                create_brain_intelligence_router(
+                    service=brain_intelligence,
+                    require_user=require_user,
+                    gate_read=platform.gate_read,
+                    gate_write=platform.gate_write,
+                    append_audit_event=append_audit_event,
+                ),
+            )
+            if create_brain_intelligence_router is not None and brain_intelligence is not None
+            else ()
+        ),
     )

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.1.0"
+ARCHITECTURE_VERSION_TARGET = "9.3.0"
 PREFERRED_REFACTORING_ORDER = [
     "agent-runtime",