ltcai 9.9.4 → 9.9.5

package/latticeai/integrations/telegram_bot.py

@@ -40,7 +40,8 @@ UPLOAD_DOC_URL  = f"{BASE_URL}/upload/document"
 AGENT_RESUME_URL      = f"{BASE_URL}/agent/resume"
 AGENT_WORKSPACE       = Path(env_value("LATTICEAI_AGENT_ROOT", "agent_workspace")).resolve()
 
-# Pending plan approvals: context_id → (chat_id, executing_model, reviewing_model)
+# Pending plan approvals keyed by run_id (or legacy context_id).
+# Values: chat_id, models, and the resume credentials (token and/or legacy).
 _bot_pending_plans: dict[str, dict] = {}
 MAX_TELEGRAM_FILE_BYTES = 45 * 1024 * 1024
 INVITE_CODE           = env_value("LATTICEAI_INVITE_CODE")
@@ -711,35 +712,65 @@ async def send_generated_files(client, chat_id, generated_files):
 
 # ── Plan approval (Human-in-the-loop) ────────────────────────────────────────
 
+def _approval_pause_id(data: dict) -> str:
+    """Stable key for a paused plan: run_id preferred, legacy context_id fallback."""
+    return str(data.get("run_id") or data.get("context_id") or "")
+
+
+def _is_approval_pause(data: dict) -> bool:
+    status = str(data.get("status") or "")
+    return status in {"waiting_approval", "awaiting_approval"}
+
+
 async def send_plan_for_approval(client, chat_id, data: dict) -> None:
-    """Show the agent plan to the user and present Done/Cancel buttons."""
-    context_id = data.get("context_id", "")
-    plan = data.get("plan", {})
-    goal = plan.get("goal", "")
-    steps = plan.get("steps", [])
+    """Show the agent plan to the user and present Done/Cancel buttons.
+
+    Handles both the modern ``awaiting_approval`` (run_id + token) and the
+    legacy ``waiting_approval`` / ``context_id`` wire contracts (v9.9.5
+    SURFACE_PARITY — Telegram approval flow).
+    """
+    pause_id = _approval_pause_id(data)
+    if not pause_id:
+        await send_message(client, chat_id, "❌ 승인할 계획을 식별할 수 없습니다.")
+        return
+    plan = data.get("plan", {}) or {}
+    goal = plan.get("goal") or (data.get("approval") or {}).get("plan_summary") or ""
+    steps = plan.get("steps", []) or data.get("non_auto_steps") or []
     p_model = data.get("planning_model", "current")
     e_model = data.get("executing_model", "current")
     r_model = data.get("reviewing_model", "current")
+    approval = data.get("approval") or {}
+    expires_at = approval.get("expires_at")
 
     lines = ["📋 *플래닝 완료* — 실행 전 확인해주세요\n"]
     if goal:
         lines.append(f"*목표:* {goal}\n")
     for i, step in enumerate(steps, 1):
-        desc = step.get("description") or step.get("action") or str(step)
+        if isinstance(step, dict):
+            desc = step.get("description") or step.get("action") or str(step)
+        else:
+            desc = str(step)
         lines.append(f"{i}. {desc}")
     lines.append(f"\n🧠 플래닝: `{p_model}`")
     lines.append(f"⚙️ 실행: `{e_model}`")
     lines.append(f"🔍 검토: `{r_model}`")
+    if expires_at:
+        lines.append(f"⏳ 승인 만료: `{expires_at}`")
 
-    _bot_pending_plans[context_id] = {
+    _bot_pending_plans[pause_id] = {
         "chat_id": chat_id,
+        "run_id": data.get("run_id") or pause_id,
+        "context_id": data.get("context_id"),
+        "approval_token": approval.get("token"),
+        "legacy": data.get("status") == "waiting_approval" or bool(data.get("context_id")),
         "executing_model": data.get("executing_model"),
         "reviewing_model": data.get("reviewing_model"),
     }
 
+    # callback_data max 64 bytes — pause ids are token_urlsafe(16) (~22 chars).
     keyboard = {"inline_keyboard": [[
-        {"text": "✅ Done — 실행 시작", "callback_data": f"plan:approve:{context_id}"},
-        {"text": "❌ 취소", "callback_data": f"plan:cancel:{context_id}"},
+        {"text": "✅ Done — 실행 시작", "callback_data": f"plan:approve:{pause_id}"},
+        {"text": "❌ 취소", "callback_data": f"plan:cancel:{pause_id}"},
     ]]}
     await send_message(client, chat_id, "\n".join(lines), reply_markup=keyboard)
 
@@ -749,8 +780,8 @@ async def handle_plan_callback(client, chat_id, data: str) -> None:
     parts = data.split(":", 2)
     if len(parts) != 3:
         return
-    _, action, context_id = parts
-    pending = _bot_pending_plans.get(context_id)
+    _, action, pause_id = parts
+    pending = _bot_pending_plans.get(pause_id)
 
     # A callback is bound to the chat that received the plan. Even two allowed
     # chats cannot approve or cancel each other's plan by replaying callback
@@ -758,9 +789,19 @@ async def handle_plan_callback(client, chat_id, data: str) -> None:
     if pending and int(pending.get("chat_id")) != int(chat_id):
         await send_message(client, chat_id, "❌ 다른 채팅의 작업은 처리할 수 없습니다.")
         return
-    pending = _bot_pending_plans.pop(context_id, None)
+    pending = _bot_pending_plans.pop(pause_id, None)
 
-    if action == "cancel" or not pending:
+    if action == "cancel":
+        if pending:
+            try:
+                resume_body = _resume_payload(pending, approved=False)
+                async with _server_client() as sc:
+                    await sc.post(AGENT_RESUME_URL, json=resume_body, timeout=30.0)
+            except Exception as exc:  # noqa: BLE001 — cancel is best-effort
+                logger.warning("telegram cancel resume failed: %s", safe_log_text(exc))
+        await send_message(client, chat_id, "❌ 작업이 취소되었습니다.")
+        return
+    if not pending:
         await send_message(client, chat_id, "❌ 작업이 취소되었습니다.")
         return
 
@@ -769,12 +810,11 @@ async def handle_plan_callback(client, chat_id, data: str) -> None:
 
     try:
         async with _server_client() as sc:
-            res = await sc.post(AGENT_RESUME_URL, json={
-                "context_id": context_id,
-                "approved": True,
-                "executing_model": pending.get("executing_model"),
-                "reviewing_model": pending.get("reviewing_model"),
-            }, timeout=300.0)
+            res = await sc.post(
+                AGENT_RESUME_URL,
+                json=_resume_payload(pending, approved=True),
+                timeout=300.0,
+            )
         data_r = res.json() if res.status_code == 200 else {}
         ans = data_r.get("response", f"❌ 서버 에러 ({res.status_code})")
         await send_message(client, chat_id, str(ans))
@@ -785,6 +825,25 @@ async def handle_plan_callback(client, chat_id, data: str) -> None:
         await send_message(client, chat_id, f"❌ 실행 중 오류: {e}")
 
 
+def _resume_payload(pending: dict, *, approved: bool) -> dict:
+    """Build /agent/resume body: token path preferred, else legacy context_id."""
+    body: dict = {
+        "approved": approved,
+        "executing_model": pending.get("executing_model"),
+        "reviewing_model": pending.get("reviewing_model"),
+    }
+    token = pending.get("approval_token")
+    run_id = pending.get("run_id")
+    # Unified durable store (9.9.5): token-gated resume works for both the
+    # modern awaiting_approval and the legacy human_in_loop pause.
+    if token and run_id:
+        body["run_id"] = run_id
+        body["approval_token"] = token
+        return body
+    body["context_id"] = pending.get("context_id") or run_id
+    return body
+
+
 # ── AI request task ───────────────────────────────────────────────────────────
 
 async def process_ai_request(client, chat_id, user_text, image_data=None):
@@ -794,8 +853,8 @@ async def process_ai_request(client, chat_id, user_text, image_data=None):
         data  = await ask_ai(client, user_text, image_data, agent_mode=not image_data)
         logger.info("ask_ai 완료: chat_id=%s result_keys=%s", chat_id, list(data.keys()) if isinstance(data, dict) else type(data))
 
-        # Human-in-the-loop: show plan and wait for approval
-        if isinstance(data, dict) and data.get("status") == "waiting_approval":
+        # Approval pause (legacy waiting_approval or modern awaiting_approval)
+        if isinstance(data, dict) and _is_approval_pause(data):
             await send_plan_for_approval(client, chat_id, data)
             return
 
@@ -887,7 +946,7 @@ async def handle_command(client, chat_id, command: str, args: str):
         await send_chat_action(client, chat_id, "typing")
         data = await ask_ai(client, task_text, agent_mode=True,
                             executing_model=exec_model, reviewing_model=reviewing_model)
-        if isinstance(data, dict) and data.get("status") == "waiting_approval":
+        if isinstance(data, dict) and _is_approval_pause(data):
             await send_plan_for_approval(client, chat_id, data)
         else:
             ans = data.get("response", str(data)) if isinstance(data, dict) else str(data)

package/latticeai/services/architecture_readiness.py

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

package/latticeai/services/product_readiness.py

@@ -18,7 +18,7 @@ from typing import Any, Dict, List
 
 from latticeai.services.architecture_readiness import architecture_readiness
 
-PRODUCT_VERSION_TARGET = "9.9.4"
+PRODUCT_VERSION_TARGET = "9.9.5"
 
 
 @dataclass(frozen=True)

package/latticeai/services/tool_dispatch.py

@@ -220,6 +220,60 @@ class ToolDispatchService:
         )
         return {"path": path, "ok": r.returncode == 0, "stderr": r.stderr[:200]}
 
+    # ── snapshot rollback ports (review L7) ──────────────────────────────
+    # Pre-write capture + restore for workspaces where git rollback does not
+    # apply (untracked new files, no git). Strictly confined to AGENT_ROOT.
+
+    _SNAPSHOT_MAX_BYTES = 512 * 1024
+
+    def _workspace_path(self, path: str) -> Optional[Path]:
+        raw = Path(path)
+        candidate = raw if raw.is_absolute() else AGENT_ROOT / raw
+        try:
+            resolved = candidate.resolve()
+            root = AGENT_ROOT.resolve()
+        except OSError:
+            return None
+        if resolved != root and root not in resolved.parents:
+            return None
+        return resolved
+
+    def snapshot_file(self, path: str) -> Dict[str, Any]:
+        """Pre-write state of a workspace file: existence + bounded content."""
+        target = self._workspace_path(path)
+        if target is None:
+            return {"existed": False, "content": None, "too_large": False,
+                    "error": "path escapes the agent workspace"}
+        if not target.exists() or not target.is_file():
+            return {"existed": False, "content": None, "too_large": False}
+        try:
+            if target.stat().st_size > self._SNAPSHOT_MAX_BYTES:
+                return {"existed": True, "content": None, "too_large": True}
+            return {
+                "existed": True,
+                "content": target.read_text(encoding="utf-8", errors="replace"),
+                "too_large": False,
+            }
+        except OSError as exc:
+            return {"existed": True, "content": None, "too_large": True,
+                    "error": str(exc)}
+
+    def restore_snapshot(self, path: str, content: Optional[str]) -> Dict[str, Any]:
+        """Restore a pre-write snapshot: rewrite prior content, or delete a
+        file the run created (``content=None``)."""
+        target = self._workspace_path(path)
+        if target is None:
+            return {"path": path, "ok": False, "error": "path escapes the agent workspace"}
+        try:
+            if content is None:
+                target.unlink(missing_ok=True)
+                return {"path": path, "ok": True, "action": "deleted"}
+            target.parent.mkdir(parents=True, exist_ok=True)
+            target.write_text(content, encoding="utf-8")
+            return {"path": path, "ok": True, "action": "restored"}
+        except OSError as exc:
+            return {"path": path, "ok": False, "error": str(exc)}
+
 
 DEFAULT_TOOL_DISPATCH_SERVICE = ToolDispatchService()
 
@@ -375,6 +429,8 @@ def build_agent_runtime(
         memory_updater_prompt=MEMORY_UPDATER_PROMPT,
         agent_root=AGENT_ROOT,
         rollback_file=dispatch_service.rollback_file,
+        snapshot_file=dispatch_service.snapshot_file,
+        restore_snapshot=dispatch_service.restore_snapshot,
         hooks=hooks,
         brain_memory=brain_memory,
     )

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ltcai",
-  "version": "9.9.4",
+  "version": "9.9.5",
   "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": {
@@ -41,6 +41,7 @@
     "test:integration": "node scripts/run_integration_tests.mjs",
     "test:browser-extension": "node --check browser-extension/popup.js && node --check browser-extension/capture-page.js && node --test tests/browser-extension.test.cjs",
     "test:visual": "playwright test",
+    "test:e2e:sidecar": "node scripts/run_sidecar_e2e.mjs",
     "vercel:build": "node scripts/build_vercel_static.mjs",
     "desktop:tauri": "tauri dev",
     "desktop:tauri:build": "tauri build",

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

package/scripts/run_sidecar_e2e.mjs

@@ -0,0 +1,159 @@
+#!/usr/bin/env node
+/**
+ * Start an isolated Lattice sidecar and run Playwright first-value E2E
+ * against it (Wave 3.2 residual / v9.9.5).
+ *
+ * Mirrors scripts/run_integration_tests.mjs isolation rules: never touch
+ * the developer's real HOME / ~/.ltcai / Brain vault.
+ */
+import { spawn } from "node:child_process";
+import { existsSync, mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const host = process.env.LTCAI_E2E_HOST || "127.0.0.1";
+if (!new Set(["127.0.0.1", "localhost"]).has(host)) {
+  throw new Error(`LTCAI_E2E_HOST must be loopback, received: ${host}`);
+}
+const port = process.env.LTCAI_E2E_PORT || "4899";
+if (!/^\d+$/.test(port) || Number(port) < 1 || Number(port) > 65535) {
+  throw new Error(`LTCAI_E2E_PORT must be 1–65535, received: ${port}`);
+}
+const baseUrl = `http://${host}:${port}`;
+const venvPython = join(process.cwd(), ".venv", "bin", "python");
+const python = process.env.PYTHON || (existsSync(venvPython) ? venvPython : "python3");
+
+const sandboxRoot = mkdtempSync(join(tmpdir(), "ltcai-e2e-"));
+const sandbox = {
+  home: join(sandboxRoot, "home"),
+  data: join(sandboxRoot, "data"),
+  brain: join(sandboxRoot, "brain"),
+  agent: join(sandboxRoot, "agent-workspace"),
+  vault: join(sandboxRoot, "vault"),
+  cache: join(sandboxRoot, "cache"),
+  config: join(sandboxRoot, "config"),
+  tmp: join(sandboxRoot, "tmp"),
+};
+for (const path of Object.values(sandbox)) mkdirSync(path, { recursive: true });
+
+const isolatedEnv = {
+  ...process.env,
+  HOME: sandbox.home,
+  USERPROFILE: sandbox.home,
+  XDG_CACHE_HOME: sandbox.cache,
+  XDG_CONFIG_HOME: sandbox.config,
+  XDG_DATA_HOME: join(sandboxRoot, "share"),
+  TMPDIR: sandbox.tmp,
+  TEMP: sandbox.tmp,
+  TMP: sandbox.tmp,
+  LATTICEAI_MODE: "local",
+  LATTICEAI_HOST: host,
+  LATTICEAI_PORT: port,
+  LATTICEAI_DATA_DIR: sandbox.data,
+  LATTICEAI_BRAIN_DIR: sandbox.brain,
+  LATTICEAI_AGENT_ROOT: sandbox.agent,
+  LATTICEAI_OBSIDIAN_VAULT_DIR: sandbox.vault,
+  LATTICEAI_STORAGE_ENGINE: "sqlite",
+  LATTICEAI_POSTGRES_DSN: "",
+  LATTICEAI_REQUIRE_AUTH: "false",
+  LATTICEAI_ENABLE_TELEGRAM: "false",
+  LATTICEAI_AUTOLOAD_MODELS: "false",
+  LATTICEAI_ALLOW_MODEL_DOWNLOADS: "false",
+  LATTICEAI_AUTO_READ_CHAT_PATHS: "false",
+  LATTICEAI_TUNNEL: "false",
+  LATTICEAI_DISCORD_PERMISSION_WEBHOOK: "",
+  LATTICEAI_DISCORD_BOT_TOKEN: "",
+  OIDC_DISCOVERY_URL: "",
+  PYTHON_KEYRING_BACKEND: "keyring.backends.null.Keyring",
+  LTCAI_E2E_BASE_URL: baseUrl,
+};
+
+let sandboxCleaned = false;
+function cleanupSandbox() {
+  if (sandboxCleaned) return;
+  sandboxCleaned = true;
+  rmSync(sandboxRoot, { recursive: true, force: true });
+}
+process.once("exit", cleanupSandbox);
+
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function waitForHealth(url, timeoutMs = 60000) {
+  const deadline = Date.now() + timeoutMs;
+  let lastError = "";
+  while (Date.now() < deadline) {
+    try {
+      const response = await fetch(`${url}/health`, { signal: AbortSignal.timeout(3000) });
+      if (response.ok) return;
+      lastError = `HTTP ${response.status}`;
+    } catch (error) {
+      lastError = String(error?.message || error);
+    }
+    await delay(500);
+  }
+  throw new Error(`Timed out waiting for ${url}/health: ${lastError}`);
+}
+
+function stop(child) {
+  return new Promise((resolve) => {
+    if (child.exitCode !== null || child.signalCode !== null) {
+      resolve();
+      return;
+    }
+    const timer = setTimeout(() => {
+      if (child.exitCode === null && child.signalCode === null) child.kill("SIGKILL");
+    }, 5000);
+    child.once("close", () => {
+      clearTimeout(timer);
+      resolve();
+    });
+    child.kill("SIGTERM");
+  });
+}
+
+async function main() {
+  console.log(`[e2e] sandbox ${sandboxRoot}`);
+  console.log(`[e2e] starting sidecar at ${baseUrl}`);
+  // Same process model as scripts/run_integration_tests.mjs: uvicorn on
+  // server:app with an isolated env. Do not double-append /health — the
+  // wait helper already probes `${url}/health`.
+  const server = spawn(
+    python,
+    ["-m", "uvicorn", "server:app", "--host", host, "--port", port],
+    { stdio: "inherit", env: isolatedEnv, cwd: process.cwd() },
+  );
+
+  let exitCode = 1;
+  try {
+    await waitForHealth(baseUrl);
+    console.log("[e2e] sidecar healthy — running Playwright");
+    // Playwright must use the host browser install (npx playwright install).
+    // The sidecar isolation rewrites HOME/XDG_* into a disposable sandbox —
+    // reusing that env here makes Chromium look under /tmp/.../ms-playwright
+    // and fail with "Executable doesn't exist".
+    const playwrightEnv = {
+      ...process.env,
+      LTCAI_E2E_BASE_URL: baseUrl,
+    };
+    const playwright = spawn(
+      "npx",
+      ["playwright", "test", "-c", "playwright.e2e.config.js"],
+      { stdio: "inherit", env: playwrightEnv, cwd: process.cwd() },
+    );
+    exitCode = await new Promise((resolve, reject) => {
+      playwright.on("error", reject);
+      playwright.on("close", (code) => resolve(code ?? 1));
+    });
+  } catch (error) {
+    console.error("[e2e] failed:", error);
+    exitCode = 1;
+  } finally {
+    await stop(server);
+    cleanupSandbox();
+  }
+  process.exit(exitCode);
+}
+
+main();

package/src-tauri/Cargo.lock

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

package/src-tauri/Cargo.toml

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

package/static/app/asset-manifest.json

@@ -1,37 +1,37 @@
 {
-  "version": "9.9.4",
+  "version": "9.9.5",
   "generated_at": "vite",
   "entrypoints": {
-    "app": "/static/app/assets/index-DrmOCySv.js"
+    "app": "/static/app/assets/index-CEu0Wqjl.js"
   },
   "assets": {
     "../node_modules/@tauri-apps/api/core.js": "/static/app/assets/core-CwxXejkd.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",
+    "_BrainSignals-r_J68_zh.js": "/static/app/assets/BrainSignals-r_J68_zh.js",
+    "_LivingBrain-BVWk58MW.js": "/static/app/assets/LivingBrain-BVWk58MW.js",
+    "_ReviewCard-Va3fPQuj.js": "/static/app/assets/ReviewCard-Va3fPQuj.js",
+    "_bot-VmP0kkeA.js": "/static/app/assets/bot-VmP0kkeA.js",
+    "_circle-pause-T9POo4qy.js": "/static/app/assets/circle-pause-T9POo4qy.js",
+    "_circle-play-Bz5iTD0p.js": "/static/app/assets/circle-play-Bz5iTD0p.js",
+    "_cpu-CJhjRtNq.js": "/static/app/assets/cpu-CJhjRtNq.js",
+    "_folder-open-B2K_22VI.js": "/static/app/assets/folder-open-B2K_22VI.js",
+    "_hard-drive-CjJtYqHf.js": "/static/app/assets/hard-drive-CjJtYqHf.js",
+    "_input-CSi6OBJ9.js": "/static/app/assets/input-CSi6OBJ9.js",
+    "_navigation-BPQqEQwr.js": "/static/app/assets/navigation-BPQqEQwr.js",
+    "_network-Ck1nqc-v.js": "/static/app/assets/network-Ck1nqc-v.js",
+    "_primitives-B2f9N7Dh.js": "/static/app/assets/primitives-B2f9N7Dh.js",
+    "_shield-alert-yA_Y8lOB.js": "/static/app/assets/shield-alert-yA_Y8lOB.js",
+    "_textarea-C4wM0D-Z.js": "/static/app/assets/textarea-C4wM0D-Z.js",
+    "_useFocusTrap-CsnIhsDJ.js": "/static/app/assets/useFocusTrap-CsnIhsDJ.js",
+    "_utils-BqoznzGP.js": "/static/app/assets/utils-BqoznzGP.js",
+    "index.html": "/static/app/assets/index-CEu0Wqjl.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"
+    "src/components/ProductFlow.tsx": "/static/app/assets/ProductFlow-B-Tz0Um4.js",
+    "src/features/brain/BrainHome.tsx": "/static/app/assets/BrainHome-CCE_0hni.js",
+    "src/features/command/CommandPalette.tsx": "/static/app/assets/CommandPalette-CVLiFIQC.js",
+    "src/pages/Act.tsx": "/static/app/assets/Act-DmxfbqBp.js",
+    "src/pages/Brain.tsx": "/static/app/assets/Brain-DK_zKCda.js",
+    "src/pages/Capture.tsx": "/static/app/assets/Capture-CvxwzpJZ.js",
+    "src/pages/Library.tsx": "/static/app/assets/Library-4As9VUvy.js",
+    "src/pages/System.tsx": "/static/app/assets/System-DSR2zKWd.js"
   }
 }