ltcai 9.9.2 → 9.9.3

package/latticeai/setup/demo_corpus.py

@@ -0,0 +1,98 @@
+"""Built-in First Value Loop demo corpus (backlog #3, review §3.3 P0).
+
+Three small Korean-friendly documents shipped in-repo so a brand-new user can
+one-click seed the Brain and immediately experience a successful recall with
+source highlighting — no folder connection, no model download, fully offline.
+
+Contract:
+
+* Documents are ingested through the normal :class:`IngestionPipeline`
+  (``source_type="note"``) with ``source_uri = demo://<id>`` and metadata
+  ``{"demo_corpus": true}`` so they are identifiable and removable later.
+* Ingestion is idempotent — the graph layer dedupes by content hash, so
+  re-POSTing never duplicates documents.
+* :data:`SUGGESTED_QUESTIONS` are pre-filled questions whose answers exist in
+  the corpus (the UI renders them as "ask this" chips).
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List
+
+DEMO_URI_PREFIX = "demo://"
+DEMO_METADATA_FLAG = "demo_corpus"
+
+DEMO_DOCUMENTS: List[Dict[str, str]] = [
+    {
+        "id": "meeting-note",
+        "title": "주간 회의록 — 사이드 프로젝트 킥오프",
+        "text": (
+            "2026-07-20 주간 회의록.\n"
+            "참석: 나, 김민준(백엔드), 박서연(디자인).\n"
+            "핵심 결정: 사이드 프로젝트 '새싹 가든'의 첫 공개 버전을 8월 15일에 "
+            "출시하기로 결정했다. 범위는 식물 기록과 물주기 알림 두 가지로 줄인다.\n"
+            "김민준이 알림 백엔드를 맡고, 박서연이 온보딩 화면을 맡는다.\n"
+            "다음 회의 전까지 각자 프로토타입을 준비하기로 했다."
+        ),
+    },
+    {
+        "id": "project-doc",
+        "title": "프로젝트 개요 — 새싹 가든",
+        "text": (
+            "새싹 가든은 집에서 키우는 식물을 기록하는 작은 앱이다.\n"
+            "기술 스택: 프론트엔드는 React, 백엔드는 FastAPI, 데이터는 SQLite에 "
+            "로컬로 저장한다. 사진은 기기 밖으로 나가지 않는다.\n"
+            "첫 버전 목표: 식물 등록, 물주기 알림, 한 줄 관찰 일기.\n"
+            "수익화는 생각하지 않고, 주말에 만드는 것을 원칙으로 한다."
+        ),
+    },
+    {
+        "id": "personal-note",
+        "title": "개인 노트 — 독서 메모: 아주 작은 습관의 힘",
+        "text": (
+            "『아주 작은 습관의 힘』을 읽고 남긴 메모.\n"
+            "가장 기억에 남는 문장: 습관은 목표가 아니라 시스템으로 만들어진다.\n"
+            "적용해 볼 것: 매일 아침 10분 스트레칭을 양치 직후에 붙여서 시작한다.\n"
+            "핵심은 2분 규칙 — 새 습관은 2분 안에 끝나는 크기로 시작하는 것이다."
+        ),
+    },
+]
+
+# Pre-filled questions whose answers exist in the corpus above. ``source_uri``
+# lets the UI verify the recall cited the right demo document.
+SUGGESTED_QUESTIONS: List[Dict[str, str]] = [
+    {
+        "question": "회의에서 결정한 출시일이 언제야?",
+        "expected_source_uri": DEMO_URI_PREFIX + "meeting-note",
+        "expected_title": "주간 회의록 — 사이드 프로젝트 킥오프",
+    },
+    {
+        "question": "새싹 가든의 기술 스택이 뭐야?",
+        "expected_source_uri": DEMO_URI_PREFIX + "project-doc",
+        "expected_title": "프로젝트 개요 — 새싹 가든",
+    },
+    {
+        "question": "새 습관을 시작할 때 쓰는 2분 규칙이 뭐였지?",
+        "expected_source_uri": DEMO_URI_PREFIX + "personal-note",
+        "expected_title": "개인 노트 — 독서 메모: 아주 작은 습관의 힘",
+    },
+]
+
+
+def demo_source_uri(doc_id: str) -> str:
+    return DEMO_URI_PREFIX + str(doc_id)
+
+
+def suggested_questions() -> List[Dict[str, Any]]:
+    """Copy of the suggestion chips (callers may annotate freely)."""
+    return [dict(item) for item in SUGGESTED_QUESTIONS]
+
+
+__all__ = [
+    "DEMO_DOCUMENTS",
+    "DEMO_METADATA_FLAG",
+    "DEMO_URI_PREFIX",
+    "SUGGESTED_QUESTIONS",
+    "demo_source_uri",
+    "suggested_questions",
+]

package/latticeai/tools/filesystem.py

@@ -6,11 +6,13 @@ Path resolution reads ``latticeai.tools.AGENT_ROOT`` so tests can redirect the s
 
 from __future__ import annotations
 
+import io
 import json
 import re
+import zipfile
 from html.parser import HTMLParser
 from pathlib import Path
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, Tuple
 
 import latticeai.tools as tools
 from latticeai.tools import (
@@ -554,3 +556,38 @@ button { padding: 10px 14px; border-radius: 10px; border: 1px solid #d6d6d6; bac
         "file_count": len(created),
         "bytes": total_bytes,
     }
+
+
+# Generous cap for a generated-project archive — the workspace itself caps
+# individual files at MAX_FILE_BYTES, this only bounds pathological trees.
+MAX_ZIP_TOTAL_BYTES = 50_000_000
+
+
+def zip_workspace_dir(path: str, max_total_bytes: int = MAX_ZIP_TOTAL_BYTES) -> Tuple[bytes, str]:
+    """Zip one workspace directory for download; confinement-safe by design.
+
+    Path resolution goes through the sandboxed ``_resolve_path`` (traversal
+    outside the agent workspace raises ``ToolError``), symlinks are skipped so
+    an in-workspace link can never leak files from elsewhere, and the archive
+    root is the directory name itself (``todo-app/index.html``).
+    """
+    target = _resolve_path(path)
+    if target == tools.AGENT_ROOT:
+        raise ToolError("Cannot zip the entire workspace root — pick a project directory.")
+    if not target.exists() or not target.is_dir():
+        raise ToolError("Path is not a directory in the workspace.")
+
+    buffer = io.BytesIO()
+    total = 0
+    with zipfile.ZipFile(buffer, "w", zipfile.ZIP_DEFLATED) as archive:
+        for child in sorted(target.rglob("*")):
+            if child.is_symlink() or not child.is_file():
+                continue
+            resolved = child.resolve()
+            if target not in resolved.parents:
+                continue  # defense in depth — never archive escaped paths
+            total += child.stat().st_size
+            if total > max_total_bytes:
+                raise ToolError("Directory is too large to zip.")
+            archive.write(child, arcname=str(child.relative_to(target.parent)))
+    return buffer.getvalue(), f"{target.name}.zip"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ltcai",
-  "version": "9.9.2",
+  "version": "9.9.3",
   "description": "Lattice AI — local-first Digital Brain that keeps your knowledge durable across any AI model.",
   "homepage": "https://github.com/TaeSooPark-PTS/LatticeAI#readme",
   "repository": {

package/scripts/bench_models.py

@@ -20,11 +20,11 @@ It measures **real code**: every output is fed through
 ``latticeai.core.agent.extract_action_details`` — the exact parser/repair
 function the production loop uses (``agent.py`` calls it in plan/execute/verify).
 An ``agent-loop`` reference row additionally runs the real
-``latticeai.core.agent_eval.run_agent_eval`` state machine over its 20
-scripted scenarios.
+``latticeai.core.agent_eval.run_agent_eval`` state machine over its full
+scripted scenario suite.
 
-Two modes
-=========
+Three modes
+===========
 1. **scripted** (default, always runnable, no model/network): a curated corpus
    of model-realistic outputs per quality tier (frontier / mid-local /
    weak-local). Proves the harness works and exposes the loop's repair boundary
@@ -34,6 +34,15 @@ Two modes
    runs the *real* completions through the same parser, measuring true
    end-to-end generation latency. Falls back to scripted with an honest message
    if the endpoint is unreachable.
+3. **filegen** (opt-in, ``--filegen``): the weekly multi-model file-generation
+   report. Discovers *installed* local gemma/qwen/llama MLX models via the
+   product's own model catalog + HF download checks, loads each with the real
+   ``LLMRouter``, and drives the real ``generate_file_content`` pipeline
+   (prompt → extract → validate → retry → repair) for each canonical file type
+   (html/css/js/py/json/md). Reports a model × filetype success matrix.
+   **FAIL-OPEN by design**: no models installed (or a load failure) yields a
+   clear skip report and exit code 0 — this mode is a scheduled/manual report,
+   never a CI gate.
 
 Honesty note on latency
 ========================
@@ -47,11 +56,14 @@ Usage
     .venv/bin/python scripts/bench_models.py --json out.json    # + machine output
     .venv/bin/python scripts/bench_models.py \
         --live-endpoint http://127.0.0.1:1234/v1 --model my-local-model
+    .venv/bin/python scripts/bench_models.py --filegen          # weekly filegen report
+    .venv/bin/python scripts/bench_models.py --filegen --json filegen_report.json
 """
 
 from __future__ import annotations
 
 import argparse
+import asyncio
 import json
 import statistics
 import sys
@@ -59,12 +71,16 @@ import time
 import urllib.error
 import urllib.request
 from pathlib import Path
-from typing import Any, Dict, List, Tuple
+from typing import Any, Awaitable, Callable, Dict, List, Optional, Tuple
 
 sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
 
 from latticeai.core.agent import extract_action_details  # noqa: E402
 from latticeai.core.agent_eval import run_agent_eval  # noqa: E402
+from latticeai.core.file_generation import (  # noqa: E402
+    generate_file_content,
+    validate_file_content,
+)
 
 
 # ── Scripted corpora ─────────────────────────────────────────────────────
@@ -226,6 +242,204 @@ def _bench_live(base_url: str, model: str, *, timeout: float) -> Dict[str, Any]:
     }
 
 
+# ── Filegen benchmark (weekly multi-model report, fail-open) ─────────────
+# One canonical request per supported file type. Requests are phrased the way
+# users actually ask, so the report measures the real prompt+pipeline, not a
+# synthetic best case.
+FILEGEN_TARGETS: List[Tuple[str, str]] = [
+    ("bench_page.html", "간단한 자기소개 웹 페이지를 만들어줘. 제목, 소개 문단, 연락처 목록을 포함해."),
+    ("bench_styles.css", "Create a stylesheet with body typography, a header rule and a .card class."),
+    ("bench_app.js", "Create a small browser script that renders a todo list and lets the user add items."),
+    ("bench_tool.py", "Create a Python script that takes a CSV file path from argv and prints the row count."),
+    ("bench_data.json", "Create a JSON document describing three sample books with title, author and year."),
+    ("bench_notes.md", "Create a Markdown document with a title, two sections and a bullet list."),
+]
+
+_FILEGEN_FAMILIES = ("gemma", "qwen", "llama")
+
+
+def discover_filegen_models() -> List[Dict[str, str]]:
+    """Installed local MLX models from the product catalog (gemma/qwen/llama).
+
+    Uses the same catalog + on-disk checks the runtime uses (``~/.ltcai``
+    model dir or the HF hub cache). Any import/probe failure is fail-open:
+    an empty list, never an exception.
+    """
+    try:
+        from latticeai.models.router import (
+            _looks_like_hf_model_dir,
+            hf_cache_model_dir,
+            hf_model_dir,
+        )
+        from latticeai.services.model_catalog import ENGINE_MODEL_CATALOG
+    except Exception as exc:  # noqa: BLE001 - discovery must never crash the report
+        print(f"filegen: model catalog unavailable ({exc}); no models discovered")
+        return []
+    found: List[Dict[str, str]] = []
+    for entry in ENGINE_MODEL_CATALOG.get("local_mlx", []):
+        model_id = str(entry.get("id") or "")
+        lowered = model_id.lower()
+        family = next((f for f in _FILEGEN_FAMILIES if f in lowered), None)
+        if not family:
+            continue
+        try:
+            downloaded = (
+                _looks_like_hf_model_dir(hf_model_dir(model_id))
+                or hf_cache_model_dir(model_id) is not None
+            )
+        except Exception:  # noqa: BLE001
+            downloaded = False
+        if downloaded:
+            found.append({"id": model_id, "family": family})
+    return found
+
+
+async def bench_filegen_model(
+    model_label: str,
+    generate_async: Callable[[str], Awaitable[str]],
+    targets: Optional[List[Tuple[str, str]]] = None,
+) -> Dict[str, Any]:
+    """Drive the real file-generation pipeline for every target file type.
+
+    ``generate_async`` is the same ``context -> raw model text`` callable shape
+    the chat layer injects, so this measures exactly what production runs
+    (extraction, validation, corrective retry, deterministic repair included).
+    """
+    rows: List[Dict[str, Any]] = []
+    for target_path, user_request in (targets or FILEGEN_TARGETS):
+        t0 = time.perf_counter()
+        content, meta = await generate_file_content(
+            generate_async, target_path=target_path, user_request=user_request,
+        )
+        elapsed_ms = round((time.perf_counter() - t0) * 1000.0, 1)
+        valid, reason = validate_file_content(content, target_path)
+        attempts = meta.get("attempts") or []
+        rows.append({
+            "target": target_path,
+            "type": target_path.rsplit(".", 1)[-1],
+            "valid": valid,                      # valid after sanitize/repair
+            "reason": reason,
+            "clean_first_try": bool(attempts and attempts[0].get("valid")),
+            "repaired": bool(meta.get("repaired")),
+            "attempts": len(attempts),
+            "latency_ms": elapsed_ms,
+            "bytes": len(content.encode("utf-8", errors="replace")),
+        })
+    total = len(rows)
+    valid_count = sum(1 for r in rows if r["valid"])
+    clean_count = sum(1 for r in rows if r["valid"] and not r["repaired"])
+    return {
+        "model": model_label,
+        "targets": rows,
+        "total": total,
+        "success_rate": round(valid_count / total, 4) if total else 0.0,
+        # Of the valid files, how many did NOT need the deterministic repair
+        # fallback — the honest "the model itself produced usable output" rate.
+        "clean_rate": round(clean_count / total, 4) if total else 0.0,
+    }
+
+
+def _make_router_generate(router: Any, model_id: str) -> Callable[[str], Awaitable[str]]:
+    """Mirror the direct chat path's generation call (chat_intents)."""
+
+    async def _generate(context: str) -> str:
+        return str(
+            await router.generate_as(
+                model_id,
+                message="Return only the requested file content.",
+                context=context,
+                max_tokens=4096,
+                temperature=0.2,
+            )
+        )
+
+    return _generate
+
+
+async def _filegen_run_models(models: List[Dict[str, str]]) -> List[Dict[str, Any]]:
+    from latticeai.models.router import LLMRouter
+
+    router = LLMRouter()
+    results: List[Dict[str, Any]] = []
+    for model in models:
+        model_id = model["id"]
+        try:
+            await router.load_model(model_id)
+        except Exception as exc:  # noqa: BLE001 - fail-open per model
+            results.append({
+                "model": model_id, "family": model["family"],
+                "skipped": True, "reason": f"load failed: {exc}",
+            })
+            continue
+        result = await bench_filegen_model(model_id, _make_router_generate(router, model_id))
+        result["family"] = model["family"]
+        results.append(result)
+        try:
+            router.unload_model(model_id)
+        except Exception:  # noqa: BLE001
+            pass
+    return results
+
+
+def run_filegen_benchmark(
+    models: Optional[List[Dict[str, str]]] = None,
+) -> Dict[str, Any]:
+    """Weekly model × filetype report. Fail-open: never raises, never gates."""
+    if models is None:
+        models = discover_filegen_models()
+    if not models:
+        return {
+            "mode": "filegen",
+            "skipped": True,
+            "reason": (
+                "no local gemma/qwen/llama models installed — install one via "
+                "the app's model picker, then re-run"
+            ),
+            "models": [],
+        }
+    try:
+        results = asyncio.run(_filegen_run_models(models))
+    except Exception as exc:  # noqa: BLE001 - fail-open at the run level too
+        return {
+            "mode": "filegen", "skipped": True,
+            "reason": f"benchmark run failed: {exc}", "models": [],
+        }
+    return {"mode": "filegen", "skipped": False, "models": results}
+
+
+def format_filegen_report(report: Dict[str, Any]) -> str:
+    lines = [
+        "Weekly filegen benchmark (real pipeline: generate_file_content)",
+        "=" * 72,
+    ]
+    if report.get("skipped"):
+        lines.append(f"SKIPPED (fail-open): {report.get('reason')}")
+        lines.append("=" * 72)
+        return "\n".join(lines)
+    for model in report.get("models", []):
+        if model.get("skipped"):
+            lines.append(f"  {model['model']}: SKIPPED — {model.get('reason')}")
+            continue
+        lines.append(
+            f"  {model['model']} "
+            f"(success={model['success_rate']}, clean={model['clean_rate']})"
+        )
+        for row in model.get("targets", []):
+            status = "ok" if row["valid"] else "FAIL"
+            if row["valid"] and row["repaired"]:
+                status = "ok(repaired)"
+            elif row["valid"] and not row["clean_first_try"]:
+                status = "ok(retry)"
+            lines.append(
+                f"    {row['type']:<5} {status:<12} "
+                f"attempts={row['attempts']} latency_ms={row['latency_ms']} "
+                f"bytes={row['bytes']}"
+            )
+    lines.append("=" * 72)
+    lines.append("note: success = valid after sanitize/repair; clean = valid without repair fallback")
+    return "\n".join(lines)
+
+
 # ── Reporting ────────────────────────────────────────────────────────────
 def _fmt_row(name: str, r: Dict[str, Any]) -> str:
     return (
@@ -243,8 +457,23 @@ def main(argv: List[str] | None = None) -> int:
     parser.add_argument("--live-endpoint", help="OpenAI-compatible base URL, e.g. http://127.0.0.1:1234/v1")
     parser.add_argument("--model", help="model id for the live endpoint")
     parser.add_argument("--timeout", type=float, default=30.0, help="live request timeout seconds")
+    parser.add_argument(
+        "--filegen", action="store_true",
+        help="weekly multi-model file-generation report (fail-open, exit 0 even with no models)",
+    )
     args = parser.parse_args(argv)
 
+    if args.filegen:
+        filegen_report = run_filegen_benchmark()
+        print(format_filegen_report(filegen_report))
+        if args.json_out:
+            Path(args.json_out).write_text(
+                json.dumps(filegen_report, ensure_ascii=False, indent=2), encoding="utf-8"
+            )
+            print(f"wrote {args.json_out}")
+        # FAIL-OPEN: this is a scheduled report, never a CI gate.
+        return 0
+
     report: Dict[str, Any] = {"mode": "scripted", "profiles": {}}
 
     # Scripted matrix (always).

package/scripts/check_current_release_docs.mjs

@@ -6,7 +6,7 @@ const root = process.cwd();
 const pkg = JSON.parse(readFileSync(path.join(root, "package.json"), "utf8"));
 const version = pkg.version;
 const releaseDir = `output/release/v${version}`;
-const releaseTheme = "Artifact Trust";
+const releaseTheme = "Closed Loops";
 const title = `${version} — ${releaseTheme}`;
 const escapedVersion = version.replaceAll(".", "\\.");
 

package/src-tauri/Cargo.lock

@@ -1584,7 +1584,7 @@ dependencies = [
 
 [[package]]
 name = "lattice-ai-desktop"
-version = "9.9.2"
+version = "9.9.3"
 dependencies = [
  "plist",
  "serde",

package/src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "lattice-ai-desktop"
-version = "9.9.2"
+version = "9.9.3"
 description = "Lattice AI Digital Brain desktop shell"
 authors = ["TaeSoo Park"]
 edition = "2021"

package/src-tauri/tauri.conf.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://schema.tauri.app/config/2",
   "productName": "Lattice AI",
-  "version": "9.9.2",
+  "version": "9.9.3",
   "identifier": "ai.lattice.desktop",
   "build": {
     "beforeDevCommand": "npm run frontend:dev",

package/static/app/asset-manifest.json

@@ -1,35 +1,36 @@
 {
-  "version": "9.9.2",
+  "version": "9.9.3",
   "generated_at": "vite",
   "entrypoints": {
-    "app": "/static/app/assets/index-BS_3aN1n.js"
+    "app": "/static/app/assets/index-CHu7cgj3.js"
   },
   "assets": {
     "../node_modules/@tauri-apps/api/core.js": "/static/app/assets/core-CwxXejkd.js",
-    "_BrainSignals-BP8-Qh2g.js": "/static/app/assets/BrainSignals-BP8-Qh2g.js",
-    "_LivingBrain-C3VbogVo.js": "/static/app/assets/LivingBrain-C3VbogVo.js",
-    "_ReviewCard-CX5RqRqx.js": "/static/app/assets/ReviewCard-CX5RqRqx.js",
-    "_bot-DZkDdh-A.js": "/static/app/assets/bot-DZkDdh-A.js",
-    "_cpu-DyvsDBbj.js": "/static/app/assets/cpu-DyvsDBbj.js",
-    "_download-C7yxYHvz.js": "/static/app/assets/download-C7yxYHvz.js",
-    "_folder-open-CffoIr9t.js": "/static/app/assets/folder-open-CffoIr9t.js",
-    "_hard-drive-C1oojrHb.js": "/static/app/assets/hard-drive-C1oojrHb.js",
-    "_input-B_U7zvbR.js": "/static/app/assets/input-B_U7zvbR.js",
-    "_navigation-xG-gyjbe.js": "/static/app/assets/navigation-xG-gyjbe.js",
-    "_network-BF13HJJF.js": "/static/app/assets/network-BF13HJJF.js",
-    "_primitives-DsuKh3M8.js": "/static/app/assets/primitives-DsuKh3M8.js",
-    "_sunrise-CIP2ELJ1.js": "/static/app/assets/sunrise-CIP2ELJ1.js",
-    "_textarea-DsDL4ET8.js": "/static/app/assets/textarea-DsDL4ET8.js",
-    "_utils-Dh-Dwtkb.js": "/static/app/assets/utils-Dh-Dwtkb.js",
-    "index.html": "/static/app/assets/index-BS_3aN1n.js",
-    "assets/index-DU78Kogz.css": "/static/app/assets/index-DU78Kogz.css",
-    "src/components/ProductFlow.tsx": "/static/app/assets/ProductFlow-BLau7c7N.js",
-    "src/features/brain/BrainHome.tsx": "/static/app/assets/BrainHome-CRUMJL93.js",
-    "src/features/command/CommandPalette.tsx": "/static/app/assets/CommandPalette-BoUTXBfm.js",
-    "src/pages/Act.tsx": "/static/app/assets/Act-Cx_gZNbE.js",
-    "src/pages/Brain.tsx": "/static/app/assets/Brain-BnGbytHa.js",
-    "src/pages/Capture.tsx": "/static/app/assets/Capture-CAKnLcb0.js",
-    "src/pages/Library.tsx": "/static/app/assets/Library-PcfVUco6.js",
-    "src/pages/System.tsx": "/static/app/assets/System-DRHc_6Su.js"
+    "_BrainSignals-CStjIqYi.js": "/static/app/assets/BrainSignals-CStjIqYi.js",
+    "_LivingBrain-DxP4efJF.js": "/static/app/assets/LivingBrain-DxP4efJF.js",
+    "_ReviewCard-C4HAO7A3.js": "/static/app/assets/ReviewCard-C4HAO7A3.js",
+    "_bot-BNDyZLR7.js": "/static/app/assets/bot-BNDyZLR7.js",
+    "_circle-play-BkhdcHgd.js": "/static/app/assets/circle-play-BkhdcHgd.js",
+    "_cpu-C6jjYm6i.js": "/static/app/assets/cpu-C6jjYm6i.js",
+    "_folder-open-DjGIvDBQ.js": "/static/app/assets/folder-open-DjGIvDBQ.js",
+    "_hard-drive-BlSbwSaT.js": "/static/app/assets/hard-drive-BlSbwSaT.js",
+    "_input-DVDI0YR3.js": "/static/app/assets/input-DVDI0YR3.js",
+    "_navigation-BddhEWA0.js": "/static/app/assets/navigation-BddhEWA0.js",
+    "_network-pYQt5oBu.js": "/static/app/assets/network-pYQt5oBu.js",
+    "_primitives-D7gCdEvS.js": "/static/app/assets/primitives-D7gCdEvS.js",
+    "_shield-alert-K9RKGQeg.js": "/static/app/assets/shield-alert-K9RKGQeg.js",
+    "_textarea-sqQmoBKL.js": "/static/app/assets/textarea-sqQmoBKL.js",
+    "_useFocusTrap-7EV9dFP2.js": "/static/app/assets/useFocusTrap-7EV9dFP2.js",
+    "_utils-uQYKXNeq.js": "/static/app/assets/utils-uQYKXNeq.js",
+    "index.html": "/static/app/assets/index-CHu7cgj3.js",
+    "assets/index-Bge3DXW7.css": "/static/app/assets/index-Bge3DXW7.css",
+    "src/components/ProductFlow.tsx": "/static/app/assets/ProductFlow-DRbm7NEq.js",
+    "src/features/brain/BrainHome.tsx": "/static/app/assets/BrainHome-CeNaxjP1.js",
+    "src/features/command/CommandPalette.tsx": "/static/app/assets/CommandPalette-DepwOQFv.js",
+    "src/pages/Act.tsx": "/static/app/assets/Act-DmdruVKV.js",
+    "src/pages/Brain.tsx": "/static/app/assets/Brain-DEY9jLVt.js",
+    "src/pages/Capture.tsx": "/static/app/assets/Capture-CVZ09QXi.js",
+    "src/pages/Library.tsx": "/static/app/assets/Library-Bp0n-HlW.js",
+    "src/pages/System.tsx": "/static/app/assets/System-ByQcmJW-.js"
   }
 }