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

ltcai 9.9.1 → 9.9.3

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

package/README.md +40 -39
package/docs/CHANGELOG.md +80 -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/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/curator.py +141 -0
package/lattice_brain/graph/documents.py +111 -0
package/lattice_brain/graph/fusion.py +179 -0
package/lattice_brain/graph/projection.py +161 -0
package/lattice_brain/graph/retrieval.py +19 -1
package/lattice_brain/ingestion.py +66 -0
package/lattice_brain/runtime/multi_agent.py +1 -1
package/latticeai/__init__.py +1 -1
package/latticeai/api/automation_intelligence.py +159 -0
package/latticeai/api/browser.py +15 -4
package/latticeai/api/chat.py +30 -2
package/latticeai/api/chat_agent_http.py +193 -4
package/latticeai/api/chat_contracts.py +7 -1
package/latticeai/api/chat_helpers.py +147 -0
package/latticeai/api/chat_intents.py +319 -8
package/latticeai/api/chat_stream.py +17 -1
package/latticeai/api/funnel_metrics.py +31 -0
package/latticeai/api/knowledge_graph.py +30 -0
package/latticeai/api/local_files.py +90 -0
package/latticeai/api/setup.py +134 -1
package/latticeai/api/tools.py +33 -3
package/latticeai/app_factory.py +15 -0
package/latticeai/core/agent.py +205 -11
package/latticeai/core/agent_eval.py +107 -0
package/latticeai/core/file_generation.py +337 -2
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/persistence_runtime.py +19 -1
package/latticeai/runtime/router_registration.py +8 -1
package/latticeai/services/app_context.py +6 -0
package/latticeai/services/architecture_readiness.py +1 -1
package/latticeai/services/automation_execution.py +266 -0
package/latticeai/services/automation_intelligence.py +7 -0
package/latticeai/services/command_center.py +20 -1
package/latticeai/services/folder_watch.py +391 -0
package/latticeai/services/funnel_metrics.py +202 -0
package/latticeai/services/product_readiness.py +6 -1
package/latticeai/services/search_service.py +17 -1
package/latticeai/services/tool_dispatch.py +36 -0
package/latticeai/setup/demo_corpus.py +98 -0
package/latticeai/tools/filesystem.py +38 -1
package/package.json +1 -1
package/scripts/bench_models.py +234 -5
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 +28 -27
package/static/app/assets/Act-DmdruVKV.js +1 -0
package/static/app/assets/{Brain-CSCDZEHd.js → Brain-DEY9jLVt.js} +2 -2
package/static/app/assets/BrainHome-CeNaxjP1.js +2 -0
package/static/app/assets/BrainSignals-CStjIqYi.js +1 -0
package/static/app/assets/{Capture-BiuerOio.js → Capture-CVZ09QXi.js} +1 -1
package/static/app/assets/CommandPalette-DepwOQFv.js +1 -0
package/static/app/assets/Library-Bp0n-HlW.js +1 -0
package/static/app/assets/{LivingBrain-6FvA0H5T.js → LivingBrain-DxP4efJF.js} +1 -1
package/static/app/assets/{ProductFlow-Cr8bkQPw.js → ProductFlow-DRbm7NEq.js} +1 -1
package/static/app/assets/ReviewCard-C4HAO7A3.js +3 -0
package/static/app/assets/{System-D6uJacqu.js → System-ByQcmJW-.js} +1 -1
package/static/app/assets/{bot-DgC7xgUl.js → bot-BNDyZLR7.js} +1 -1
package/static/app/assets/circle-play-BkhdcHgd.js +1 -0
package/static/app/assets/{cpu-DDGb4XHl.js → cpu-C6jjYm6i.js} +1 -1
package/static/app/assets/{folder-open-BbVuSO9M.js → folder-open-DjGIvDBQ.js} +1 -1
package/static/app/assets/{hard-drive-yDZR6XYz.js → hard-drive-BlSbwSaT.js} +1 -1
package/static/app/assets/index-Bge3DXW7.css +2 -0
package/static/app/assets/{index-DrZSkwrE.js → index-CHu7cgj3.js} +3 -3
package/static/app/assets/{input-DPIkTs9n.js → input-DVDI0YR3.js} +1 -1
package/static/app/assets/{navigation-B1mkmyUe.js → navigation-BddhEWA0.js} +1 -1
package/static/app/assets/{network-0XDI1Uf_.js → network-pYQt5oBu.js} +1 -1
package/static/app/assets/{primitives-sIQYKyf5.js → primitives-D7gCdEvS.js} +1 -1
package/static/app/assets/shield-alert-K9RKGQeg.js +1 -0
package/static/app/assets/{textarea-DvnwpnqS.js → textarea-sqQmoBKL.js} +1 -1
package/static/app/assets/useFocusTrap-7EV9dFP2.js +1 -0
package/static/app/assets/utils-uQYKXNeq.js +7 -0
package/static/app/index.html +4 -4
package/static/sw.js +1 -1
package/static/app/assets/Act-CcSWTQsx.js +0 -1
package/static/app/assets/BrainHome-B5QpJ1Fx.js +0 -2
package/static/app/assets/BrainSignals-CmFD8PWk.js +0 -1
package/static/app/assets/CommandPalette-BrqpT7K2.js +0 -1
package/static/app/assets/Library-BcaiPbum.js +0 -1
package/static/app/assets/ReviewCard-D56TMypk.js +0 -1
package/static/app/assets/download-C-Ei3GFa.js +0 -1
package/static/app/assets/index-CFRhNBuH.css +0 -2
package/static/app/assets/sunrise-DXMjueec.js +0 -1
package/static/app/assets/utils-BrfFHAJl.js +0 -7

package/latticeai/core/agent_eval.py CHANGED Viewed

@@ -163,6 +163,18 @@ class Scenario:
     # canned results (node ids, snippets, proposal ids), so an answer that is
     # not grounded in the retrieved/executed evidence fails the scenario.
     expect_final_contains: List[str] = field(default_factory=list)
+    # Exact per-name counts against the LoopTrace ``repairs`` histogram —
+    # filegen scenarios use this to prove the ArtifactWritePipeline actually
+    # fired (``artifact_sanitize`` / ``artifact_repair``), not merely that
+    # the tool ran.
+    expect_repairs: Dict[str, int] = field(default_factory=dict)
+    # Content-level assertions on what file-writing tools actually received
+    # AFTER sanitize: every ``contains`` needle must appear in at least one
+    # written payload, every ``excludes`` needle in none. This is the teeth
+    # of the dirty-write scenarios — a fence or chat wrapper reaching the
+    # tool port fails the gate.
+    expect_write_contains: List[str] = field(default_factory=list)
+    expect_write_excludes: List[str] = field(default_factory=list)
     max_steps: int = 8
@@ -247,6 +259,37 @@ _WRITE = '{"action": "write_file", "args": {"path": "note.txt", "content": "hi"}
 _FINAL = '{"action": "final", "message": "done"}'
 _PASS = '{"action": "verdict", "verdict": "PASS", "next_state": "DONE", "reason": "ok"}'
+# ── dirty write_file payloads (ArtifactWritePipeline scenarios) ──────────
+# What weak local models actually put in args.content: chat framing + a
+# Markdown fence around the document. The JSON envelope itself is valid —
+# the dirt is *inside* the content string, so only the write-side sanitize
+# pass (agent.py _dispatch_step → sanitize_write_content) can clean it.
+_DIRTY_HTML_CONTENT = (
+    "Sure! Here is your page:\\n"
+    "```html\\n"
+    "<!DOCTYPE html>\\n<html>\\n<head><meta charset=\\\"utf-8\\\">"
+    "<title>Hello</title></head>\\n<body><h1>Hello</h1></body>\\n</html>\\n"
+    "```\\n"
+    "Hope this helps! Let me know if you need changes."
+)
+_DIRTY_WRITE = (
+    '{"thoughts": "produce the page", "action": "write_file", '
+    '"args": {"path": "pages/hello.html", "content": "' + _DIRTY_HTML_CONTENT + '"}}'
+)
+# Token-limit casualty: the document just stops mid-body (no </body>/</html>).
+_TRUNCATED_HTML_CONTENT = (
+    "<!DOCTYPE html>\\n<html>\\n<head><meta charset=\\\"utf-8\\\">"
+    "<title>Weekly</title></head>\\n<body>\\n<h1>Weekly report</h1>"
+)
+_TRUNCATED_WRITE = (
+    '{"thoughts": "write the report", "action": "write_file", '
+    '"args": {"path": "reports/weekly.html", "content": "' + _TRUNCATED_HTML_CONTENT + '"}}'
+)
+_FILEGEN_PLAN = (
+    '{"action": "plan", "goal": "save the requested web page to disk", '
+    '"steps": [{"action": "write_file"}]}'
+)
 def default_scenarios() -> List[Scenario]:
     return [
@@ -551,6 +594,54 @@ def default_scenarios() -> List[Scenario]:
             expected_class="failed",
             expect_tool_outcomes={"error": 1},
         ),
+        # ── ArtifactWritePipeline (write-side sanitize) ─────────────────
+        Scenario(
+            name="filegen-dirty-write-sanitized-critic-pass",
+            # Weak model wraps args.content in prose + a Markdown fence. The
+            # sanitize pass must strip the wrapper BEFORE the tool runs, the
+            # trace must record artifact_sanitize, and the critic PASS then
+            # completes over a transcript whose written payload is clean.
+            replies=[_FILEGEN_PLAN, _DIRTY_WRITE, _FINAL, _PASS],
+            expect_exact={"parse_errors": 0},
+            expect_tool_outcomes={"ok": 1},
+            expect_tool_calls=["write_file"],
+            expect_repairs={"artifact_sanitize": 1},
+            expect_write_contains=["<!DOCTYPE html>", "</html>"],
+            expect_write_excludes=["```", "Sure!", "Hope this helps"],
+        ),
+        Scenario(
+            name="filegen-truncated-write-repaired-critic-pass",
+            # Token-limit truncation: no extractable clean document exists, so
+            # the pipeline's deterministic repair must close the document
+            # (artifact_repair) — the file on disk is still structurally valid.
+            replies=[_FILEGEN_PLAN, _TRUNCATED_WRITE, _FINAL, _PASS],
+            expect_exact={"parse_errors": 0},
+            expect_tool_outcomes={"ok": 1},
+            expect_tool_calls=["write_file"],
+            expect_repairs={"artifact_repair": 1},
+            expect_write_contains=["<h1>Weekly report</h1>", "</body>", "</html>"],
+            expect_write_excludes=["```"],
+        ),
+        Scenario(
+            name="filegen-dirty-write-unverifiable-needs-review",
+            # The dirty write is sanitized and runs, but the critic never
+            # produces a parseable verdict — fail-closed: the run must end
+            # NEEDS_REVIEW (never a fabricated DONE), while the written file
+            # stays clean because sanitize ran before the tool.
+            replies=[
+                _FILEGEN_PLAN, _DIRTY_WRITE, _FINAL,
+                "the page looks great, approving!",       # unparseable critic
+                "still prose, still not a JSON verdict",  # strict retry fails too
+            ],
+            expect_state="NEEDS_REVIEW",
+            expected_class="needs_review",
+            expect_min={"parse_errors": 2},
+            expect_tool_outcomes={"ok": 1},
+            expect_tool_calls=["write_file"],
+            expect_repairs={"artifact_sanitize": 1},
+            expect_write_excludes=["```", "Sure!"],
+            expect_final_contains=["직접 확인"],
+        ),
     ]
@@ -591,6 +682,22 @@ async def _run_scenario(scenario: Scenario) -> Dict[str, Any]:
     for needle in scenario.expect_final_contains:
         if needle not in ctx.final_message:
             failures.append(f"final_message missing {needle!r}")
+    for repair_name, count in scenario.expect_repairs.items():
+        seen = int((summary.get("repairs") or {}).get(repair_name, 0))
+        if seen != count:
+            failures.append(f"repairs[{repair_name}]={seen} != {count}")
+    # Payloads the file-writing tools actually received (post-sanitize).
+    written = [
+        str((call.get("args") or {}).get("content") or "")
+        for call in tool_log
+        if call["name"] in ("write_file", "generate_file")
+    ]
+    for needle in scenario.expect_write_contains:
+        if not any(needle in payload for payload in written):
+            failures.append(f"written content missing {needle!r}")
+    for needle in scenario.expect_write_excludes:
+        if any(needle in payload for payload in written):
+            failures.append(f"written content must not contain {needle!r}")
     if governor is not None and summary["tool_outcomes"].get("proposed", 0) != len(governor.proposals):
         failures.append(
             f"governor proposals={len(governor.proposals)} != "

package/latticeai/core/file_generation.py CHANGED Viewed

@@ -25,6 +25,7 @@ The pipeline is pure (no I/O, no FastAPI); the chat layer injects an async
 from __future__ import annotations
+import ast
 import html as html_lib
 import json
 import re
@@ -91,6 +92,8 @@ _EXT_FENCE_LANGS: Dict[str, Tuple[str, ...]] = {
     ".xml": ("xml", "svg"),
     ".csv": ("csv",),
     ".txt": ("txt", "text", "plaintext"),
+    ".vue": ("vue", "html"),
+    ".svelte": ("svelte", "html"),
 }
@@ -181,6 +184,76 @@ def looks_like_refusal(content: str) -> bool:
     return bool(_REFUSAL_RE.search(head)) and len(content) < 600
+# Braced code types validated structurally (balanced delimiters, no fences).
+_BRACED_CODE_EXTENSIONS = frozenset({".js", ".jsx", ".ts", ".tsx"})
+# Single-file components validated by their block tags being closed.
+_COMPONENT_EXTENSIONS = frozenset({".vue", ".svelte"})
+def _strip_code_literals(text: str) -> str:
+    """Remove string literals and comments so delimiter counting stays honest.
+    A cheap single-pass scanner (not a parser): quotes ('', "", ``), line
+    comments (//) and block comments (/* */) commonly contain lone braces
+    that would otherwise false-flag valid JS/TS as unbalanced.
+    """
+    out: List[str] = []
+    i, n = 0, len(text)
+    while i < n:
+        ch = text[i]
+        nxt = text[i + 1] if i + 1 < n else ""
+        if ch == "\\":
+            i += 2  # escaped char (inside or outside a literal — always skip)
+            continue
+        if ch in ("'", '"', "`"):
+            quote = ch
+            i += 1
+            while i < n:
+                if text[i] == "\\":
+                    i += 2
+                    continue
+                if text[i] == quote:
+                    i += 1
+                    break
+                i += 1
+            continue
+        if ch == "/" and nxt == "/":
+            while i < n and text[i] != "\n":
+                i += 1
+            continue
+        if ch == "/" and nxt == "*":
+            end = text.find("*/", i + 2)
+            i = n if end < 0 else end + 2
+            continue
+        out.append(ch)
+        i += 1
+    return "".join(out)
+def _check_balanced_delimiters(content: str) -> Tuple[bool, str]:
+    """Lenient count-based balance check for braced code (js/ts family).
+    Only *counts* are compared, never ordering, so valid-but-unusual code is
+    not rejected; a truncated file with a dangling ``{`` still fails.
+    """
+    stripped = _strip_code_literals(content)
+    for opener, closer, label in (("{", "}", "braces"), ("(", ")", "parentheses"), ("[", "]", "brackets")):
+        if stripped.count(opener) != stripped.count(closer):
+            return False, f"unbalanced {label} ({opener}{closer}) — the file looks truncated"
+    return True, "ok"
+def _check_component_blocks(content: str) -> Tuple[bool, str]:
+    """Vue/Svelte SFC sanity: every opened block tag must be closed."""
+    lower = content.lower()
+    for tag in ("template", "script", "style"):
+        opened = len(re.findall(rf"<{tag}(?:\s[^>]*)?>", lower))
+        closed = lower.count(f"</{tag}>")
+        if opened != closed:
+            return False, f"<{tag}> block is not closed — the component looks truncated"
+    return True, "ok"
 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():
@@ -195,6 +268,14 @@ def validate_file_content(content: str, target_path: str) -> Tuple[bool, str]:
             return False, "not a complete HTML document (missing <!DOCTYPE html>/<html>)"
         if "</html>" not in lower:
             return False, "HTML document is truncated (missing </html>)"
+        # A document that merely *contains* html somewhere is not a valid
+        # file payload: fenced/chat-wrapped replies must fail here so the
+        # extraction pass gets a chance to slice out the real document.
+        stripped = content.lstrip()
+        if not (stripped.lower().startswith("<!doctype") or stripped.lower().startswith("<html")):
+            return False, "HTML document is wrapped in prose or fences"
+        if "```" in content:
+            return False, "output still contains Markdown fences"
         return True, "ok"
     if ext == ".json":
         try:
@@ -203,10 +284,28 @@ def validate_file_content(content: str, target_path: str) -> Tuple[bool, str]:
             return False, f"invalid JSON: {exc}"
         return True, "ok"
     if ext == ".css":
+        if "```" in content:
+            return False, "output still contains Markdown fences"
         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 ext == ".py":
+        if "```" in content:
+            return False, "output still contains Markdown fences"
+        try:
+            ast.parse(content)
+        except SyntaxError as exc:
+            return False, f"invalid Python syntax: {exc.msg} (line {exc.lineno})"
+        return True, "ok"
+    if ext in _BRACED_CODE_EXTENSIONS:
+        if "```" in content:
+            return False, "output still contains Markdown fences"
+        return _check_balanced_delimiters(content)
+    if ext in _COMPONENT_EXTENSIONS:
+        if "```" in content:
+            return False, "output still contains Markdown fences"
+        return _check_component_blocks(content)
+    if ext in (".sh", ".sql"):
         if "```" in content:
             return False, "output still contains Markdown fences"
         return True, "ok"
@@ -240,13 +339,31 @@ _TYPE_RULES: Dict[str, str] = {
     ".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.",
+    ".jsx": "Produce one complete React component file in JSX.",
+    ".ts": "Produce complete valid TypeScript source code.",
+    ".tsx": "Produce one complete React component file in TSX (TypeScript).",
+    ".vue": "Produce ONE complete Vue single-file component with closed <template>/<script>/<style> blocks.",
+    ".svelte": "Produce ONE complete Svelte component; every <script>/<style> block must be closed.",
 }
+# Multi-file bundles override the standalone-HTML rule: the page must link
+# its sibling files instead of inlining everything.
+_BUNDLE_HTML_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 part of a multi-file project: link the project stylesheet(s) "
+    "with <link rel=\"stylesheet\" href=\"...\"> and load the project script(s) "
+    "with <script src=\"...\"></script> just before </body>. Reference ONLY the "
+    "project files listed below — no other external files, no inline <style> "
+    "blocks, no inline behavior scripts."
+)
 def build_file_generation_context(
     target_path: str,
     user_request: str,
     feedback: Optional[str] = None,
+    bundle_files: Optional[List[str]] = None,
 ) -> str:
     """Strict, extension-aware generation instructions.
@@ -263,8 +380,13 @@ def build_file_generation_context(
         "no text before or after the content.",
     ]
     type_rule = _TYPE_RULES.get(ext)
+    if bundle_files and ext in (".html", ".htm"):
+        type_rule = _BUNDLE_HTML_RULE
     if type_rule:
         parts.append(f"- {type_rule}")
+    if bundle_files:
+        listed = ", ".join(bundle_files)
+        parts.append(f"- Project files in this bundle: {listed}")
     first_line = _FIRST_LINE_HINTS.get(ext)
     if first_line:
         parts.append(f"- The very first line of your reply must be: {first_line}")
@@ -301,12 +423,29 @@ def repair_file_content(content: str, target_path: str, user_request: str) -> st
             ensure_ascii=False,
             indent=2,
         )
+    if ext == ".py" and salvage:
+        # The repair guarantee for Python is parseability: unparseable output
+        # is preserved honestly as a commented-out draft, never as a broken
+        # module the user has to debug.
+        try:
+            ast.parse(salvage)
+            return salvage
+        except SyntaxError:
+            commented = "\n".join(f"# {line}" for line in salvage.splitlines())
+            return (
+                f"# TODO: model produced invalid Python for: {user_request}\n"
+                "# The draft below is preserved as comments — fix and uncomment.\n"
+                f"{commented}\n"
+            )
     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: ",
+        ".jsx": "// TODO: model produced no usable content for: ",
+        ".ts": "// TODO: model produced no usable content for: ",
+        ".tsx": "// 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: ",
@@ -359,6 +498,55 @@ def _repair_html(salvage: str, user_request: str) -> str:
     )
+# Extensions the Brain UI can render inline (preview) after creation.
+PREVIEWABLE_EXTENSIONS = frozenset({
+    ".html", ".htm", ".md", ".markdown", ".txt", ".json", ".css", ".js",
+    ".csv", ".py", ".yaml", ".yml", ".xml", ".sql", ".sh",
+    ".jsx", ".ts", ".tsx", ".vue", ".svelte",
+})
+# ── write-side sanitize (ArtifactWritePipeline) ─────────────────────────
+def sanitize_write_content(
+    target_path: str,
+    content: Any,
+    user_request: str = "",
+) -> Tuple[str, Dict[str, Any]]:
+    """Single write-side guarantee for model-produced file content.
+    The direct chat path already runs the full generate→validate→repair
+    pipeline, but the agent JSON loop historically wrote ``args.content``
+    verbatim — weak models routinely put fenced/chatty payloads there. This
+    conservative sanitizer closes that gap for *any* write entry point:
+    1. content that already validates is returned byte-for-byte unchanged
+       (trusted/user-authored content is never mangled);
+    2. otherwise the extraction pass strips fences/think-blocks/chat noise
+       and is used only when the extracted payload validates;
+    3. otherwise deterministic repair guarantees a structurally valid file.
+    Empty content is left untouched (creating an empty file is a legitimate,
+    intentional action — e.g. ``__init__.py``). Returns ``(content, meta)``
+    where meta is ``{"sanitized": bool, "repaired": bool, "reason": str}``.
+    """
+    raw = str(content or "")
+    if not raw.strip():
+        return raw, {"sanitized": False, "repaired": False, "reason": "empty"}
+    ok, reason = validate_file_content(raw, target_path)
+    if ok:
+        return raw, {"sanitized": False, "repaired": False, "reason": "ok"}
+    extracted = extract_file_content(raw, target_path)
+    if extracted:
+        extracted_ok, _ = validate_file_content(extracted, target_path)
+        if extracted_ok:
+            return extracted, {"sanitized": True, "repaired": False, "reason": reason}
+    repaired = repair_file_content(
+        extracted or raw, target_path, user_request or f"content for {target_path}"
+    )
+    return repaired, {"sanitized": True, "repaired": True, "reason": reason}
 # ── filename inference ──────────────────────────────────────────────────
 _CREATE_VERB_RE = re.compile(
@@ -401,6 +589,145 @@ def infer_file_target(message: str) -> Optional[str]:
     return None
+# ── project manifest (multi-file bundles) ───────────────────────────────
+# ``\b`` fails against Korean particles ("js로") because Hangul is ``\w`` —
+# use ASCII lookarounds so type keywords match with or without a particle.
+_HTML_HINT_RE = re.compile(
+    r"(?<![a-z0-9])html(?![a-z0-9])"
+    r"|웹\s*페이지|웹페이지|홈페이지|웹\s*사이트|웹사이트|website|web\s*page|landing\s*page",
+)
+_CSS_HINT_RE = re.compile(r"(?<![a-z0-9])css(?![a-z0-9])|스타일\s*시트|stylesheet")
+_JS_HINT_RE = re.compile(
+    r"(?<![a-z0-9])js(?![a-z0-9])|javascript|자바스크립트|자바\s*스크립트"
+)
+# An explicit filename means the user is managing paths — keep the
+# deterministic single-file flow untouched.
+_EXPLICIT_FILENAME_RE = re.compile(
+    r"[\w-]+\.(?:html?|css|js|jsx|ts|tsx|py|json|md|txt|csv|vue|svelte)\b",
+    re.IGNORECASE,
+)
+_PROJECT_NAME_RE = re.compile(r"([A-Za-z][A-Za-z0-9_-]{1,30})\s*(?:앱|app\b)", re.IGNORECASE)
+def infer_project_manifest(message: str) -> Optional[Dict[str, Any]]:
+    """Infer a multi-file web-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
+    single-file flow is completely unchanged.
+    """
+    text = (message or "").strip()
+    if not text or not _CREATE_VERB_RE.search(text):
+        return None
+    if _EXPLICIT_FILENAME_RE.search(text):
+        return None
+    lower = text.lower()
+    wants_html = bool(_HTML_HINT_RE.search(lower))
+    wants_css = bool(_CSS_HINT_RE.search(lower))
+    wants_js = bool(_JS_HINT_RE.search(lower))
+    if not wants_html or not (wants_css or wants_js):
+        return None
+    name_match = _PROJECT_NAME_RE.search(text)
+    name = f"{name_match.group(1).lower()}-app" if name_match else "web-project"
+    files: List[Dict[str, str]] = []
+    html_refs: List[str] = []
+    if wants_css:
+        html_refs.append('<link rel="stylesheet" href="style.css"> in <head>')
+    if wants_js:
+        html_refs.append('<script src="app.js"></script> just before </body>')
+    files.append({
+        "path": "index.html",
+        "brief": (
+            "The main HTML page of the project. Reference the sibling files: "
+            + " and ".join(html_refs)
+            + ". Do not inline styles or behavior scripts."
+        ),
+    })
+    if wants_css:
+        files.append({
+            "path": "style.css",
+            "brief": "All visual styles for index.html (layout, colors, typography).",
+        })
+    if wants_js:
+        files.append({
+            "path": "app.js",
+            "brief": (
+                "All page behavior for index.html as plain browser JavaScript "
+                "(no build step, no imports of missing files)."
+            ),
+        })
+    return {"name": name, "kind": "web", "files": files}
+_HTML_LOCAL_REF_RE = re.compile(
+    r"(?:href|src)\s*=\s*[\"']([^\"'#?]+)[\"']", re.IGNORECASE
+)
+_EXTERNAL_REF_PREFIXES = ("http://", "https://", "//", "data:", "mailto:", "tel:", "javascript:")
+def _local_bundle_refs(html: str) -> List[str]:
+    """File references inside an HTML document that must exist in the bundle."""
+    refs: List[str] = []
+    for ref in _HTML_LOCAL_REF_RE.findall(html or ""):
+        candidate = ref.strip()
+        if not candidate or candidate.startswith(_EXTERNAL_REF_PREFIXES):
+            continue
+        if "." not in candidate.rsplit("/", 1)[-1]:
+            continue  # anchors / routes, not files
+        refs.append(candidate)
+    return refs
+def repair_bundle_references(files: Dict[str, str]) -> Tuple[Dict[str, str], List[str]]:
+    """Deterministically point dangling HTML refs at real bundle files.
+    A weak model asked for ``style.css`` sometimes links ``styles.css``. When
+    a referenced file is missing but the bundle contains exactly one file of
+    the same extension, the reference is rewritten. Returns ``(files, fixes)``.
+    """
+    names = {p.rsplit("/", 1)[-1] for p in files}
+    fixes: List[str] = []
+    repaired = dict(files)
+    for path, content in files.items():
+        if _ext(path) not in (".html", ".htm"):
+            continue
+        updated = content
+        for ref in _local_bundle_refs(content):
+            base = ref.rsplit("/", 1)[-1]
+            if base in names:
+                continue
+            same_ext = [n for n in names if _ext(n) == _ext(base)]
+            if len(same_ext) == 1:
+                updated = updated.replace(ref, same_ext[0])
+                fixes.append(f"{path}: '{ref}' -> '{same_ext[0]}'")
+        if updated != content:
+            repaired[path] = updated
+    return repaired, fixes
+def validate_project_bundle(files: Dict[str, str]) -> Dict[str, Any]:
+    """Bundle-level verification: every file valid, every HTML ref resolvable."""
+    issues: List[str] = []
+    per_file: Dict[str, Dict[str, Any]] = {}
+    names = {p.rsplit("/", 1)[-1] for p in files}
+    for path, content in files.items():
+        ok, reason = validate_file_content(content, path)
+        per_file[path] = {"valid": ok, "reason": reason}
+        if not ok:
+            issues.append(f"{path}: {reason}")
+        if _ext(path) in (".html", ".htm"):
+            for ref in _local_bundle_refs(content):
+                if ref.rsplit("/", 1)[-1] not in names:
+                    issues.append(f"{path}: references missing file '{ref}'")
+    return {"ok": not issues, "issues": issues, "files": per_file}
 # ── orchestration ───────────────────────────────────────────────────────
 async def generate_file_content(
@@ -409,6 +736,7 @@ async def generate_file_content(
     target_path: str,
     user_request: str,
     max_attempts: int = 2,
+    bundle_files: Optional[List[str]] = None,
 ) -> Tuple[str, Dict[str, Any]]:
     """Generate validated file content with any LLM.
@@ -421,7 +749,9 @@ async def generate_file_content(
     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)
+        context = build_file_generation_context(
+            target_path, user_request, feedback=feedback, bundle_files=bundle_files,
+        )
         try:
             raw = await generate(context)
         except Exception as exc:  # model backend hiccup — repair still delivers
@@ -441,11 +771,16 @@ async def generate_file_content(
 __all__ = [
+    "PREVIEWABLE_EXTENSIONS",
     "build_file_generation_context",
     "extract_file_content",
     "generate_file_content",
     "infer_file_target",
+    "infer_project_manifest",
     "looks_like_refusal",
+    "repair_bundle_references",
     "repair_file_content",
+    "sanitize_write_content",
     "validate_file_content",
+    "validate_project_bundle",
 ]

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.1"
+LEGACY_COMPATIBILITY_VERSION = "9.9.3"
 @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.1"
+MARKETPLACE_VERSION = "9.9.3"
 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.9.1"
+WORKSPACE_OS_VERSION = "9.9.3"
 # Workspace types separate single-user Personal workspaces from shared
 # Organization workspaces. Both keep the same local-first JSON store; the type

package/latticeai/runtime/persistence_runtime.py CHANGED Viewed

@@ -38,6 +38,7 @@ def build_persistence_runtime(
     from latticeai.core.workspace_os import WorkspaceOSStore
     from latticeai.services.automation_intelligence import AutomationIntelligenceService
     from latticeai.services.brain_intelligence import BrainIntelligenceService
+    from latticeai.services.funnel_metrics import FunnelMetricsService
     from latticeai.services.memory_service import MemoryService
     from latticeai.services.workspace_service import WorkspaceService
@@ -70,11 +71,27 @@ def build_persistence_runtime(
         store=workspace_os,
         enable_graph=enable_graph,
     )
+    # UX funnel metrics (backlog #16): cheap JSON counters under the data dir.
+    # The ingestion pipeline's audit seam is wrapped so every successful
+    # ingest bumps the funnel (and starts the TTFV clock) without touching
+    # lattice_brain internals.
+    funnel_metrics = FunnelMetricsService(Path(data_dir) / "funnel_metrics.json")
+    def _funnel_audit(action, detail, user):
+        try:
+            if action == "kg_ingest":
+                funnel_metrics.record_ingest(
+                    duplicate=bool((detail or {}).get("duplicate"))
+                )
+        except Exception:  # noqa: BLE001 — metrics must never break ingestion
+            pass
+        audit(action, detail, user)
     ingestion_pipeline = IngestionPipeline(
         knowledge_graph,
         hooks=hooks_registry,
         enable_graph=enable_graph,
-        audit=audit,
+        audit=_funnel_audit,
     )
     device_identity = DeviceIdentity(data_dir)
     kg_portability = KGPortabilityService(
@@ -99,4 +116,5 @@ def build_persistence_runtime(
         "INGESTION_PIPELINE": ingestion_pipeline,
         "DEVICE_IDENTITY": device_identity,
         "KG_PORTABILITY": kg_portability,
+        "FUNNEL_METRICS": funnel_metrics,
     }

package/latticeai/runtime/router_registration.py CHANGED Viewed

@@ -605,6 +605,7 @@ def register_review_and_brain_tail_routers(
     create_setup_router: Any,
     model_router: Any,
     change_proposals: Any = None,
+    knowledge_graph: Any = None,
 ) -> Any:
     """Register the final review/browser/brain tail routes in legacy order."""
@@ -644,6 +645,12 @@ def register_review_and_brain_tail_routers(
             require_admin=require_admin,
         ),
         create_garden_router(gardener=gardener, require_user=require_user),
-        create_setup_router(model_router=model_router, require_user=require_user),
+        create_setup_router(
+            model_router=model_router,
+            require_user=require_user,
+            ingestion_pipeline=ingestion_pipeline,
+            knowledge_graph=knowledge_graph,
+            workspace_service=workspace_service,
+        ),
     )
     return brain_network