ltcai 9.9.2 → 9.9.4

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 = "Durable Loops";
 const title = `${version} — ${releaseTheme}`;
 const escapedVersion = version.replaceAll(".", "\\.");
 

package/scripts/funnel_soft_gate.py

@@ -0,0 +1,192 @@
+#!/usr/bin/env python3
+"""Funnel soft gate (review Wave 3.3) — funnel metrics as an advisory verdict.
+
+Reads the same ``funnel_metrics.json`` production writes and grades it through
+``FunnelMetricsService.snapshot()`` — no rate logic is duplicated here. Two
+funnel-health rates carry WARN thresholds:
+
+* ``code_only_rate``    — WARN above 0.05 (goal: >95% of recognized file
+  requests deliver a real artifact, not a code/prose-only answer);
+* ``needs_review_rate`` — WARN above 0.30 (verifier fail-closed is healthy,
+  but a third of runs ending NEEDS_REVIEW means verification is starving).
+
+Rates whose denominator is still zero come back ``None`` from the snapshot;
+they are reported as "no data" and never warn — a fresh install stays green.
+``real_file_rate``, ``approval_resume_rate`` and TTFV are shown as
+informational context only.
+
+Exit codes
+==========
+* default         — advisory: ALWAYS ``0``; warnings are printed, not enforced;
+* ``--strict``    — CI opt-in: ``1`` when any WARN fired ("no data" never
+  fails, even under --strict);
+* bad flags       — argparse's usual ``2`` (the only real script error).
+
+Usage
+=====
+    .venv/bin/python scripts/funnel_soft_gate.py                 # advisory report
+    .venv/bin/python scripts/funnel_soft_gate.py --strict        # CI gate opt-in
+    .venv/bin/python scripts/funnel_soft_gate.py --json          # machine output
+    .venv/bin/python scripts/funnel_soft_gate.py --path /tmp/m.json
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+from latticeai.services.funnel_metrics import FunnelMetricsService  # noqa: E402
+
+# Advisory thresholds (overridable per run via flags). WARN fires strictly
+# ABOVE the threshold, so a rate sitting exactly on the goal boundary passes.
+CODE_ONLY_WARN_THRESHOLD = 0.05
+NEEDS_REVIEW_WARN_THRESHOLD = 0.30
+
+
+def default_metrics_path() -> Path:
+    """The exact file production writes: ``Config.from_env`` data-dir pattern
+    (``LATTICEAI_DATA_DIR`` env or ``~/.ltcai``) + the ``funnel_metrics.json``
+    filename from ``latticeai/runtime/persistence_runtime.py``."""
+    data_dir = Path(os.environ.get("LATTICEAI_DATA_DIR") or (Path.home() / ".ltcai"))
+    return data_dir / "funnel_metrics.json"
+
+
+def evaluate_snapshot(
+    snapshot: Dict[str, Any],
+    *,
+    code_only_warn: float = CODE_ONLY_WARN_THRESHOLD,
+    needs_review_warn: float = NEEDS_REVIEW_WARN_THRESHOLD,
+) -> Dict[str, Any]:
+    """Grade a ``FunnelMetricsService.snapshot()`` payload into verdicts."""
+    rates = snapshot.get("rates") or {}
+    checks: List[Dict[str, Any]] = []
+
+    def check(name: str, threshold: float, goal: str) -> None:
+        rate: Optional[float] = rates.get(name)
+        if rate is None:
+            verdict, detail = "no_data", "no denominator recorded yet"
+        elif rate > threshold:
+            verdict, detail = "warn", f"{rate} > {threshold} — {goal}"
+        else:
+            verdict, detail = "ok", f"{rate} <= {threshold}"
+        checks.append({
+            "name": name, "rate": rate, "threshold": threshold,
+            "verdict": verdict, "detail": detail,
+        })
+
+    check("code_only_rate", code_only_warn,
+          "goal: >95% of file requests deliver real files")
+    check("needs_review_rate", needs_review_warn,
+          "goal: <30% of agent runs end NEEDS_REVIEW")
+
+    warnings = [c["name"] for c in checks if c["verdict"] == "warn"]
+    if warnings:
+        status = "warn"
+    elif all(c["verdict"] == "no_data" for c in checks):
+        status = "no_data"
+    else:
+        status = "ok"
+    return {
+        "status": status,
+        "warnings": warnings,
+        "checks": checks,
+        # Informational context — never gated.
+        "info": {
+            "real_file_rate": rates.get("real_file_rate"),
+            "approval_resume_rate": rates.get("approval_resume_rate"),
+            "ttfv_seconds": snapshot.get("ttfv_seconds"),
+            "counters": snapshot.get("counters") or {},
+        },
+    }
+
+
+def format_report(payload: Dict[str, Any]) -> str:
+    lines = [
+        f"Funnel soft gate (advisory) — {payload['path']}",
+        "=" * 72,
+    ]
+    for check in payload["checks"]:
+        rate = "no data" if check["rate"] is None else str(check["rate"])
+        verdict = {"warn": "WARN", "ok": "ok", "no_data": "-"}[check["verdict"]]
+        lines.append(
+            f"  {check['name']:<20} {rate:<8} {verdict:<5} {check['detail']}"
+        )
+    info = payload["info"]
+    lines.append("-" * 72)
+    lines.append(
+        f"  info: real_file_rate={info['real_file_rate']} "
+        f"approval_resume_rate={info['approval_resume_rate']} "
+        f"ttfv_seconds={info['ttfv_seconds']}"
+    )
+    lines.append("=" * 72)
+    if payload["status"] == "warn":
+        mode = (
+            "STRICT — exiting 1" if payload["strict"]
+            else "advisory — exit 0; opt into enforcement with --strict"
+        )
+        lines.append(f"verdict: WARN ({', '.join(payload['warnings'])}) [{mode}]")
+    elif payload["status"] == "no_data":
+        lines.append("verdict: no data yet — nothing to grade (exit 0)")
+    else:
+        lines.append("verdict: OK — funnel rates within goals")
+    return "\n".join(lines)
+
+
+def main(argv: List[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        description="Advisory funnel-metrics gate (warn on funnel-health regressions)"
+    )
+    parser.add_argument(
+        "--path",
+        help="metrics JSON path (default: the production data-dir funnel_metrics.json)",
+    )
+    parser.add_argument(
+        "--strict", action="store_true",
+        help="exit 1 when any WARN fired (CI opt-in; 'no data' still exits 0)",
+    )
+    parser.add_argument(
+        "--json", dest="json_out", action="store_true",
+        help="print the machine-readable verdict JSON to stdout",
+    )
+    parser.add_argument(
+        "--code-only-warn", type=float, default=CODE_ONLY_WARN_THRESHOLD,
+        help=f"code_only_rate WARN threshold (default {CODE_ONLY_WARN_THRESHOLD})",
+    )
+    parser.add_argument(
+        "--needs-review-warn", type=float, default=NEEDS_REVIEW_WARN_THRESHOLD,
+        help=f"needs_review_rate WARN threshold (default {NEEDS_REVIEW_WARN_THRESHOLD})",
+    )
+    args = parser.parse_args(argv)
+
+    path = Path(args.path) if args.path else default_metrics_path()
+    # A missing or corrupt file yields the service's zeroed state → all rates
+    # None → "no data" (never a crash, never a failure).
+    snapshot = FunnelMetricsService(path).snapshot()
+    result = evaluate_snapshot(
+        snapshot,
+        code_only_warn=args.code_only_warn,
+        needs_review_warn=args.needs_review_warn,
+    )
+    exit_code = 1 if (args.strict and result["status"] == "warn") else 0
+    payload = {
+        "mode": "funnel-soft-gate",
+        "path": str(path),
+        "strict": bool(args.strict),
+        "exit_code": exit_code,
+        **result,
+    }
+    if args.json_out:
+        print(json.dumps(payload, ensure_ascii=False, indent=2))
+    else:
+        print(format_report(payload))
+    return exit_code
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/src-tauri/Cargo.lock

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

package/src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "lattice-ai-desktop"
-version = "9.9.2"
+version = "9.9.4"
 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.4",
   "identifier": "ai.lattice.desktop",
   "build": {
     "beforeDevCommand": "npm run frontend:dev",

package/static/app/asset-manifest.json

@@ -1,35 +1,37 @@
 {
-  "version": "9.9.2",
+  "version": "9.9.4",
   "generated_at": "vite",
   "entrypoints": {
-    "app": "/static/app/assets/index-BS_3aN1n.js"
+    "app": "/static/app/assets/index-DrmOCySv.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-C52lwZVD.js": "/static/app/assets/BrainSignals-C52lwZVD.js",
+    "_LivingBrain-Jlf2wFqI.js": "/static/app/assets/LivingBrain-Jlf2wFqI.js",
+    "_ReviewCard-DWvD7n9h.js": "/static/app/assets/ReviewCard-DWvD7n9h.js",
+    "_bot-nB_buEZD.js": "/static/app/assets/bot-nB_buEZD.js",
+    "_circle-pause-DLNw6Ucp.js": "/static/app/assets/circle-pause-DLNw6Ucp.js",
+    "_circle-play-B-IsFL1y.js": "/static/app/assets/circle-play-B-IsFL1y.js",
+    "_cpu-CEPBHaBl.js": "/static/app/assets/cpu-CEPBHaBl.js",
+    "_folder-open-hmN0N9cX.js": "/static/app/assets/folder-open-hmN0N9cX.js",
+    "_hard-drive-CBV_B_Yd.js": "/static/app/assets/hard-drive-CBV_B_Yd.js",
+    "_input-gtVCg-ll.js": "/static/app/assets/input-gtVCg-ll.js",
+    "_navigation-Bot0hvuv.js": "/static/app/assets/navigation-Bot0hvuv.js",
+    "_network-jE42eKfT.js": "/static/app/assets/network-jE42eKfT.js",
+    "_primitives-CX2Komon.js": "/static/app/assets/primitives-CX2Komon.js",
+    "_shield-alert-BftATuAA.js": "/static/app/assets/shield-alert-BftATuAA.js",
+    "_textarea-CiMJfOSI.js": "/static/app/assets/textarea-CiMJfOSI.js",
+    "_useFocusTrap-B7RPGfFy.js": "/static/app/assets/useFocusTrap-B7RPGfFy.js",
+    "_utils-SJUNVOj5.js": "/static/app/assets/utils-SJUNVOj5.js",
+    "index.html": "/static/app/assets/index-DrmOCySv.js",
+    "assets/index-7FAfYm4v.css": "/static/app/assets/index-7FAfYm4v.css",
+    "src/components/ProductFlow.tsx": "/static/app/assets/ProductFlow-yg1fKP1P.js",
+    "src/features/brain/BrainHome.tsx": "/static/app/assets/BrainHome-BJ3sFNX0.js",
+    "src/features/command/CommandPalette.tsx": "/static/app/assets/CommandPalette-90u9FWFH.js",
+    "src/pages/Act.tsx": "/static/app/assets/Act-BCmTU0E2.js",
+    "src/pages/Brain.tsx": "/static/app/assets/Brain-CTnjox7w.js",
+    "src/pages/Capture.tsx": "/static/app/assets/Capture-B6vBhFa3.js",
+    "src/pages/Library.tsx": "/static/app/assets/Library-pKCK0_tk.js",
+    "src/pages/System.tsx": "/static/app/assets/System-BAEuHqNY.js"
   }
 }