@meridiona/meridian-darwin-arm64 1.8.2 → 1.9.1

package/VERSION

@@ -1 +1 @@
-1.8.2
+1.9.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meridiona/meridian-darwin-arm64",
-  "version": "1.8.2",
+  "version": "1.9.1",
   "description": "Prebuilt Meridian app for macOS arm64 (daemon binary + dashboard + Python services). Installed via @meridiona/meridian.",
   "homepage": "https://github.com/Meridiona/meridian",
   "repository": {

package/scripts/install-from-bundle.sh

@@ -65,6 +65,40 @@ PLIST
     launchctl kickstart -k "${GUI_TARGET}/${label}" 2>/dev/null || true
 }
 
+# Enable accessibility mode in VS Code / Cursor / Antigravity so screenpipe
+# captures their a11y tree instead of falling back to OCR. Chromium/Electron
+# editors only expose their AX tree when editor.accessibilitySupport = "on"
+# (the force-renderer-accessibility argv switch is Linux-only on macOS).
+# Idempotent + JSONC-safe (preserves existing keys/comments). Without this, npm
+# users' editors silently OCR-only until they discover the setting by hand.
+configure_editor_accessibility() {
+    local support_root="${HOME}/Library/Application Support"
+    local editors=("Code" "Cursor" "Antigravity IDE")
+    local any=0 ed dir settings
+    for ed in "${editors[@]}"; do
+        dir="${support_root}/${ed}"
+        [[ -d "$dir" ]] || continue           # editor not installed → skip
+        any=1
+        settings="${dir}/User/settings.json"
+        if [[ -f "$settings" ]] && grep -q '"editor.accessibilitySupport"' "$settings"; then
+            ok "${ed}: editor.accessibilitySupport already set — keeping"
+            continue
+        fi
+        mkdir -p "${dir}/User"
+        if [[ ! -s "$settings" ]]; then
+            printf '{\n\t"editor.accessibilitySupport": "on"\n}\n' > "$settings"
+        else
+            cp "$settings" "${settings}.meridian-bak"
+            # Insert the key after the first `{`. VS Code-family parsers are
+            # JSONC-tolerant, so this preserves existing keys/comments/formatting.
+            perl -0777 -i -pe 's/\{/\{\n\t"editor.accessibilitySupport": "on",/ unless $done++' "$settings"
+        fi
+        ok "${ed}: enabled editor.accessibilitySupport = on (restart the editor)"
+    done
+    [[ "$any" -eq 0 ]] && info "No VS Code / Cursor / Antigravity install found — skipping editor a11y setup"
+    return 0
+}
+
 # ── 0. Platform gate ────────────────────────────────────────────────────────
 [[ "$(uname -s)" == "Darwin" ]]  || { err "Meridian requires macOS."; exit 1; }
 [[ "$(uname -m)" == "arm64" ]]   || { err "Meridian requires Apple Silicon (arm64). This bundle is macOS-arm64 only."; exit 1; }
@@ -144,6 +178,10 @@ if [[ "${SKIP_PERMISSIONS}" -eq 0 ]]; then
     read -r -p "  Press Enter once both are granted… " _ || true
 fi
 
+# Enable a11y mode in installed VS Code-family editors (idempotent). Without
+# this, screenpipe falls back to OCR for those editors instead of their a11y tree.
+configure_editor_accessibility
+
 # ── 6. Daemons (reuse the hardened installers; UI runs the standalone server) ─
 info "Installing screenpipe launchd agent…"
 bash "${APP_ROOT}/scripts/install-screenpipe-daemon.sh" || warn "screenpipe agent install failed"

package/services/agents/llm_selector.py

@@ -79,6 +79,7 @@ _MODELS = [
     ("phi-4",           "mlx",  8.5, 80, "mlx-community/phi-4-4bit"),
     ("r1-14b",          "mlx",  8.5, 78, "mlx-community/DeepSeek-R1-Distill-Qwen-14B-4bit"),
     ("gemma3-12b",      "mlx",  7.0, 75, "mlx-community/gemma-3-12b-it-qat-4bit"),
+    ("qwen3.5-9b-optiq","mlx",  6.5, 74, "mlx-community/Qwen3.5-9B-OptiQ-4bit"),  # eval-tuned classifier default
     ("qwen3.5-4b",      "mlx",  2.5, 65, "mlx-community/Qwen3.5-4B-MLX-4bit"),
     ("llama3.2-3b",     "mlx",  1.8, 62, "mlx-community/Llama-3.2-3B-Instruct-4bit"),
     ("apple-intelligence", "apple_fm", 0.0, 60, None),
@@ -203,16 +204,23 @@ def discover_running_servers() -> list[RunningServer]:
             else:
                 log.debug("llm_selector: no server on port 8080")
 
-            # 4. Apple FoundationModels — in-process, no port, macOS 26+
+            # 4. Apple FoundationModels — in-process, no port, macOS 26+.
+            #    is_available() is an INSTANCE method returning (bool, reason).
+            #    Catch broadly (not just ImportError): an absent OR API-skewed
+            #    apple_fm_sdk must degrade to "not found", never crash the whole
+            #    discovery sweep (which would push every caller to cloud).
             try:
                 from apple_fm_sdk import SystemLanguageModel  # type: ignore[import]
-                if SystemLanguageModel.default.is_available()[0]:
+                available, reason = SystemLanguageModel().is_available()
+                if available:
                     found.append(RunningServer(
                         "apple_fm", "", ["apple-intelligence"], "apple-intelligence"))
                     log.info("llm_selector: Apple Intelligence available")
                     span.add_event("apple_fm_found")
-            except ImportError:
-                pass
+                else:
+                    log.debug("llm_selector: Apple Intelligence unavailable: %s", reason)
+            except Exception as exc:  # noqa: BLE001 — SDK absent or version-skewed
+                log.debug("llm_selector: Apple FM probe skipped: %s", exc)
 
             span.set_attribute("servers.found", len(found))
             span.set_attribute("servers.names", str([s.runtime for s in found]))
@@ -457,9 +465,13 @@ def _infer_apple_intelligence(system: str, user: str, max_tokens: int) -> Option
         import asyncio
         from apple_fm_sdk import LanguageModelSession  # type: ignore[import]
         async def _run() -> str:
-            session = LanguageModelSession(system_prompt=system)
-            r = await session.respond(prompt=user)
-            return r.content
+            # Constructor kwarg is `instructions` (the system prompt). respond()
+            # is a coroutine; in free-form mode it resolves to a plain str, while
+            # guided modes return a GeneratedContent with a .content attr — handle
+            # both. (max_tokens is governed by the SDK's own GenerationOptions.)
+            session = LanguageModelSession(instructions=system)
+            r = await session.respond(user)
+            return getattr(r, "content", r)
         return asyncio.run(_run())
     except Exception as exc:
         log.warning("llm_selector: apple_fm failed: %s", exc)
@@ -801,6 +813,156 @@ def select_model_for_hermes(budget_pct: Optional[float] = None) -> Optional[Loca
             raise
 
 
+def _hf_model_cached(hf_id: "str | None") -> bool:
+    """True when a HuggingFace repo's weights are already in the local cache.
+
+    A best-effort filesystem check so dynamic selection never picks a catalog
+    model that would trigger a multi-GB ``snapshot_download`` (online) or raise
+    (offline) inside ``mlx_lm.load`` at server startup. Honours HF_HUB_CACHE /
+    HF_HOME, falling back to ~/.cache/huggingface/hub. Mirrors the
+    "best among what's present" philosophy of discover_running_servers().
+    """
+    if not hf_id:
+        return False
+    hf_home = os.environ.get("HF_HOME")
+    cache = (
+        os.environ.get("HF_HUB_CACHE")
+        or (os.path.join(hf_home, "hub") if hf_home else None)
+        or str(Path.home() / ".cache" / "huggingface" / "hub")
+    )
+    snapshots = Path(cache) / ("models--" + hf_id.replace("/", "--")) / "snapshots"
+    if not snapshots.is_dir():
+        return False
+    # A revision directory that actually contains files (not just an empty shell).
+    for rev in snapshots.iterdir():
+        if rev.is_dir() and any(rev.iterdir()):
+            return True
+    return False
+
+
+def select_mlx_model_id(
+    preferred_hf_id: "str | None" = None,
+    preferred_min_ram_gb: float = 0.0,
+    budget_pct: "float | None" = None,
+) -> "str | None":
+    """Pick the best **in-process** MLX model id for this machine.
+
+    Selection-only sibling of select_model_for_hermes(): returns a HuggingFace
+    repo id the caller loads directly via mlx_lm + outlines (FSM-constrained
+    decoding). It deliberately does NOT discover external servers
+    (Ollama / LM Studio / Apple Intelligence give no constrained decoding) and
+    does NOT spawn a managed mlx_lm.server — the MLX classifier server loads the
+    chosen model in-process and is the single LLM host for every stage.
+
+    Priority:
+      1. ``preferred_hf_id`` when it fits the Metal headroom budget — the
+         eval-tuned classifier model. Keep it on capable machines; degrade only
+         when it physically won't fit, so a generic catalog ``quality_score``
+         never silently swaps out the tuned model on a big box.
+      2. The largest catalog model that fits (``_select_mlx_entry``).
+      3. ``preferred_hf_id`` as a best-effort fallback when nothing in the
+         catalog fits — let ``mlx_lm.load`` try rather than returning None and
+         breaking the load.
+
+    Returns None only when no ``preferred_hf_id`` is given and nothing fits.
+    """
+    if budget_pct is None:
+        try:
+            from agents.config import LLM_BUDGET_PCT
+            budget_pct = LLM_BUDGET_PCT
+        except Exception:
+            budget_pct = 0.5
+
+    with _tracer.start_as_current_span("llm_selector.select_mlx_model_id") as span:
+        span.set_attribute("llm.preferred_hf_id", preferred_hf_id or "")
+        span.set_attribute("llm.preferred_min_ram_gb", preferred_min_ram_gb)
+        span.set_attribute("llm.budget_pct", budget_pct)
+
+        # Non-Apple-Silicon: no MLX runtime — return the preferred default so the
+        # caller's behaviour is unchanged (the load path no-ops/fails as before).
+        if platform.system() != "Darwin":
+            span.set_attribute("llm.reason", "not_darwin")
+            span.set_attribute("llm.selected_model", preferred_hf_id or "")
+            return preferred_hf_id
+        brand = _sysctl("machdep.cpu.brand_string") or ""
+        if not brand.startswith("Apple M"):
+            span.set_attribute("llm.reason", "not_apple_silicon")
+            span.set_attribute("llm.selected_model", preferred_hf_id or "")
+            return preferred_hf_id
+
+        try:
+            snap = probe_compute()
+        except Exception as exc:  # noqa: BLE001
+            span.record_exception(exc)
+            span.set_attribute("llm.reason", "compute_probe_failed")
+            span.set_attribute("llm.selected_model", preferred_hf_id or "")
+            log.warning("llm_selector: compute probe failed (%s) — using %s",
+                        exc, preferred_hf_id)
+            return preferred_hf_id
+
+        # Relax the budget when the screen is locked — the user won't feel the
+        # latency — and mirror _select_mlx_entry's heavy-throttle cap so the
+        # preferred-fit check sees the same budget the catalog ladder does.
+        effective_pct = (
+            min(0.8, budget_pct * 1.5) if snap.screen_locked else budget_pct
+        )
+        budget = snap.metal_headroom_gb * effective_pct
+        if snap.thermal_level >= 2:
+            budget = min(budget, 9.0)
+
+        span.set_attribute("llm.headroom_gb",   round(snap.metal_headroom_gb, 2))
+        span.set_attribute("llm.effective_pct", round(effective_pct, 3))
+        span.set_attribute("llm.budget_gb",     round(budget, 2))
+        span.set_attribute("llm.thermal_level", snap.thermal_level)
+        span.set_attribute("llm.screen_locked", snap.screen_locked)
+
+        # 1. Keep the tuned classifier model when it fits.
+        if preferred_hf_id and preferred_min_ram_gb <= budget:
+            span.set_attribute("llm.reason", "preferred_fits")
+            span.set_attribute("llm.selected_model", preferred_hf_id)
+            log.info(
+                "llm_selector: MLX in-process model=%s (preferred — min_ram=%.1f GB "
+                "fits budget=%.1f GB)",
+                preferred_hf_id, preferred_min_ram_gb, budget,
+            )
+            return preferred_hf_id
+
+        # 2. Largest catalog model that BOTH fits the budget AND is already in
+        #    the HF cache. Gating on the cache keeps "dynamic" meaning "best
+        #    among what's present" — never a surprise multi-GB download (or an
+        #    offline load failure that would kill server startup) on exactly the
+        #    constrained machines this degradation path targets. The `budget`
+        #    here is already thermal-capped, matching _select_mlx_entry.
+        for model_id, backend, min_ram, quality, hf_id in _MODELS:
+            if backend != "mlx" or min_ram > budget:
+                continue
+            if not _hf_model_cached(hf_id):
+                log.debug(
+                    "llm_selector: skip %s — fits budget=%.1f GB but not in HF cache",
+                    hf_id, budget,
+                )
+                continue
+            span.set_attribute("llm.reason", "catalog_fit_cached")
+            span.set_attribute("llm.selected_model", hf_id)
+            log.info(
+                "llm_selector: MLX in-process model=%s hf=%s min_ram=%.1f GB "
+                "quality=%d cached (preferred=%s did not fit budget=%.1f GB)",
+                model_id, hf_id, min_ram, quality, preferred_hf_id, budget,
+            )
+            return hf_id
+
+        # 3. Nothing cached fits the budget — best effort with the preferred id.
+        #    (Loading preferred-when-absent is the pre-existing single-model
+        #    behaviour, not a regression introduced by dynamic selection.)
+        span.set_attribute("llm.reason", "nothing_cached_fits_use_preferred")
+        span.set_attribute("llm.selected_model", preferred_hf_id or "")
+        log.warning(
+            "llm_selector: no cached MLX model fits budget=%.1f GB — falling back to %s",
+            budget, preferred_hf_id,
+        )
+        return preferred_hf_id
+
+
 def resolve_model(name: str) -> "dict | None":
     """Resolve a short name ('phi-4') or HF ID to its catalog entry.
 
@@ -837,7 +999,8 @@ def discover_mlx_eval_server(port: int = 7823) -> "str | None":
 
 __all__ = ["local_infer", "discover_running_servers", "probe_compute",
            "RunningServer", "ComputeSnapshot", "LocalModelEndpoint",
-           "select_model_for_hermes", "shutdown_managed_server",
+           "select_model_for_hermes", "select_mlx_model_id",
+           "shutdown_managed_server",
            "resolve_model", "discover_mlx_eval_server"]
 
 # Public alias (no underscore) for external callers

package/services/agents/run_task_linker_mlx.py

@@ -50,9 +50,63 @@ _CONTEXT_WINDOW = 5
 _MAX_TOKENS = 1024
 _TEMPERATURE = 0.0  # greedy decoding — deterministic classification
 
-_MLX_MODEL_ID = os.environ.get(
-    "MLX_MODEL_ID", "mlx-community/Qwen3.5-9B-OptiQ-4bit"
-)
+# The eval-tuned default classifier model. It lives in the llm_selector catalog
+# (_MODELS) as "qwen3.5-9b-optiq"; llm_selector keeps it on machines where it
+# fits and degrades only when Metal headroom can't accommodate it. The catalog
+# is the single source of truth for its working-set footprint — the constant
+# below is only the fallback used if the lookup ever fails (~5-6 GB resident for
+# the 9B-4bit weights, plus KV cache at our 1024-token generation budget).
+_DEFAULT_MLX_MODEL_ID = "mlx-community/Qwen3.5-9B-OptiQ-4bit"
+_DEFAULT_MLX_MODEL_MIN_RAM_GB = 6.5
+
+# Explicit pin — set MLX_MODEL_ID to bypass dynamic selection entirely (eval
+# experiments, reproducible benchmarks). When unset, the model is chosen at
+# runtime by llm_selector.select_mlx_model_id() based on available compute.
+_MLX_MODEL_ID_PIN = os.environ.get("MLX_MODEL_ID")
+
+# Resolved lazily and cached for the process lifetime by _resolve_model_id().
+# Kept as a module attribute (not just a function return) so /info, /v1/models,
+# and the llm_inference span all report the same, truthful id.
+_MLX_MODEL_ID: str | None = None
+
+
+def _resolve_model_id() -> str:
+    """Resolve the MLX model id for this process — once, then cached.
+
+    Order: explicit MLX_MODEL_ID pin → dynamic selection via llm_selector →
+    the hardcoded eval-tuned default on any failure. Never returns None so the
+    in-process load always has a concrete id to hand mlx_lm.load.
+    """
+    global _MLX_MODEL_ID
+    if _MLX_MODEL_ID is not None:
+        return _MLX_MODEL_ID
+
+    if _MLX_MODEL_ID_PIN:
+        _MLX_MODEL_ID = _MLX_MODEL_ID_PIN
+        log.info("run_task_linker_mlx: model pinned via MLX_MODEL_ID=%s", _MLX_MODEL_ID)
+        return _MLX_MODEL_ID
+
+    try:
+        from agents.llm_selector import resolve_model, select_mlx_model_id
+        entry = resolve_model(_DEFAULT_MLX_MODEL_ID)
+        preferred_min_ram = (
+            entry["min_ram_gb"] if entry else _DEFAULT_MLX_MODEL_MIN_RAM_GB
+        )
+        _MLX_MODEL_ID = select_mlx_model_id(
+            preferred_hf_id=_DEFAULT_MLX_MODEL_ID,
+            preferred_min_ram_gb=preferred_min_ram,
+        ) or _DEFAULT_MLX_MODEL_ID
+    except Exception as exc:  # noqa: BLE001
+        log.warning(
+            "run_task_linker_mlx: dynamic model selection failed (%s) — "
+            "using default %s", exc, _DEFAULT_MLX_MODEL_ID,
+        )
+        _MLX_MODEL_ID = _DEFAULT_MLX_MODEL_ID
+
+    log.info("run_task_linker_mlx: resolved MLX model=%s", _MLX_MODEL_ID)
+    return _MLX_MODEL_ID
+
+
 _SKILL_PATH = (
     _SERVICES_DIR / "skills" / "activity" / "task-classifier" / "SKILL.md"
 )
@@ -185,8 +239,9 @@ _model_cache: dict[str, Any] = {}
 
 def _get_model() -> Any:
     """Return an outlines-wrapped model, loading from disk on the first call."""
-    if _MLX_MODEL_ID in _model_cache:
-        return _model_cache[_MLX_MODEL_ID]
+    model_id = _resolve_model_id()
+    if model_id in _model_cache:
+        return _model_cache[model_id]
 
     try:
         import mlx_lm
@@ -198,17 +253,17 @@ def _get_model() -> Any:
         ) from exc
 
     log.info(
-        "run_task_linker_mlx: loading %s (first call this process)", _MLX_MODEL_ID
+        "run_task_linker_mlx: loading %s (first call this process)", model_id
     )
     t0 = time.time()
     mlx_model, tokenizer = mlx_lm.load(
-        _MLX_MODEL_ID,
+        model_id,
         tokenizer_config={"trust_remote_code": True},
     )
     outlines_model = outlines.from_mlxlm(mlx_model, tokenizer)
     log.info("run_task_linker_mlx: model loaded in %.1fs", time.time() - t0)
 
-    _model_cache[_MLX_MODEL_ID] = outlines_model
+    _model_cache[model_id] = outlines_model
     return outlines_model
 
 
@@ -369,7 +424,7 @@ def _classify_one(
     # ── llm_inference ─────────────────────────────────────────────────────────
     t0 = time.time()
     with tracer.start_as_current_span("llm_inference") as llm_span:
-        llm_span.set_attribute("model", _MLX_MODEL_ID)
+        llm_span.set_attribute("model", _resolve_model_id())
         llm_span.set_attribute("max_tokens", _MAX_TOKENS)
         llm_span.set_attribute("temperature", _TEMPERATURE)
         llm_span.add_event("inference_started", {"session_id": session_id})

package/services/agents/server.py

@@ -95,7 +95,7 @@ async def info() -> dict:
     m = _app_state.get("mlx_module")
     return {
         "backend":   _app_state.get("backend", "hermes"),
-        "model_id":  m._MLX_MODEL_ID if m else None,
+        "model_id":  m._resolve_model_id() if m else None,
         "loaded_at": _app_state.get("loaded_at"),
     }
 
@@ -646,8 +646,8 @@ async def openai_models_list() -> dict:
     model_id = "qwen3.5-9b-instruct"
     if _app_state.get("backend") == "mlx":
         m = _app_state.get("mlx_module")
-        if m is not None and hasattr(m, "_MLX_MODEL_ID"):
-            model_id = m._MLX_MODEL_ID
+        if m is not None and hasattr(m, "_resolve_model_id"):
+            model_id = m._resolve_model_id()
     return {
         "object": "list",
         "data": [

package/services/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "meridian-agents"
-version = "1.8.2"
+version = "1.9.1"
 description = "Meridian agents — hermes task linking and Jira progress updates for meridian.db"
 requires-python = ">=3.11"
 authors = [{ name = "Meridiona" }]

package/ui/.next/BUILD_ID

@@ -1 +1 @@
-YiKEh58OA_EMvMLKy2O82
+LmsmKuJ_nDSy0cz06W0Qm

package/ui/.next/app-path-routes-manifest.json

@@ -1,14 +1,14 @@
 {
-  "/_global-error/page": "/_global-error",
   "/_not-found/page": "/_not-found",
-  "/api/active/route": "/api/active",
-  "/api/coding-agents/route": "/api/coding-agents",
-  "/api/queue-review/route": "/api/queue-review",
+  "/_global-error/page": "/_global-error",
   "/api/settings/route": "/api/settings",
+  "/api/active/route": "/api/active",
   "/api/tasks/route": "/api/tasks",
-  "/api/today/route": "/api/today",
+  "/api/queue-review/route": "/api/queue-review",
   "/api/week/route": "/api/week",
+  "/api/coding-agents/route": "/api/coding-agents",
   "/api/worklogs/[id]/route": "/api/worklogs/[id]",
+  "/api/today/route": "/api/today",
   "/api/worklogs/route": "/api/worklogs",
   "/page": "/",
   "/settings/page": "/settings"

package/ui/.next/build-manifest.json

@@ -1,20 +1,20 @@
 {
-  "pages": {
-    "/_app": []
-  },
-  "devFiles": [],
   "polyfillFiles": [
-    "static/chunks/03~yq9q893hmn.js"
+    "static/chunks/polyfills-42372ed130431b0a.js"
   ],
+  "devFiles": [],
   "lowPriorityFiles": [
-    "static/YiKEh58OA_EMvMLKy2O82/_buildManifest.js",
-    "static/YiKEh58OA_EMvMLKy2O82/_ssgManifest.js",
-    "static/YiKEh58OA_EMvMLKy2O82/_clientMiddlewareManifest.js"
+    "static/LmsmKuJ_nDSy0cz06W0Qm/_buildManifest.js",
+    "static/LmsmKuJ_nDSy0cz06W0Qm/_ssgManifest.js"
   ],
   "rootMainFiles": [
-    "static/chunks/120gq8w9i9o8g.js",
-    "static/chunks/140ovxvjat1ch.js",
-    "static/chunks/07lhk_q6pmm3r.js",
-    "static/chunks/turbopack-0_6a5_lndzekh.js"
-  ]
+    "static/chunks/webpack-2269c302c37a39ed.js",
+    "static/chunks/4bd1b696-215e5051988c3dde.js",
+    "static/chunks/794-5fb6eff04a716ab6.js",
+    "static/chunks/main-app-a3be861f7b636915.js"
+  ],
+  "rootMainFilesTree": {},
+  "pages": {
+    "/_app": []
+  }
 }

package/ui/.next/prerender-manifest.json

@@ -102,8 +102,8 @@
   "dynamicRoutes": {},
   "notFoundRoutes": [],
   "preview": {
-    "previewModeId": "ad83f3a1e67d5fa319c1642e26cb0227",
-    "previewModeSigningKey": "42639ac54a9e9b028e9b7154328294085bd463cc41a0fcd78eebb77753036c15",
-    "previewModeEncryptionKey": "6a834a131a02762f3e6bb2fe540d008b18d0beb315a8284e7a312d796c0d977a"
+    "previewModeId": "a2c372ef7f1a5f8d8e7f152a50d26caf",
+    "previewModeSigningKey": "d72b8a7fb72816955e740657432d0d6e9e4f3addbdf97e8d08c5f7a7436ae4d7",
+    "previewModeEncryptionKey": "7f44e507d53f5279a289cb64555647b9e8c1fde0042cd80d6fb1f01b176d3884"
   }
 }

package/ui/.next/react-loadable-manifest.json

@@ -0,0 +1,45 @@
+{
+  "app/page.tsx -> @/components/views/QueueView": {
+    "id": 8370,
+    "files": [
+      "static/chunks/370.9c4833c55fb6317e.js"
+    ]
+  },
+  "app/page.tsx -> @/components/views/SessionsView": {
+    "id": 4384,
+    "files": [
+      "static/chunks/384.af02665a82a56eac.js"
+    ]
+  },
+  "app/page.tsx -> @/components/views/SettingsView": {
+    "id": 9157,
+    "files": [
+      "static/chunks/612.c27b08d531e545a4.js",
+      "static/chunks/157.3e25a7ac5b48b2a8.js"
+    ]
+  },
+  "app/page.tsx -> @/components/views/TasksView": {
+    "id": 7949,
+    "files": [
+      "static/chunks/949.5adbbd4c964d435b.js"
+    ]
+  },
+  "app/page.tsx -> @/components/views/TodayView": {
+    "id": 6470,
+    "files": [
+      "static/chunks/470.6939cb6d4f31b6d7.js"
+    ]
+  },
+  "app/page.tsx -> @/components/views/WeekView": {
+    "id": 9611,
+    "files": [
+      "static/chunks/611.3c377a30258276a4.js"
+    ]
+  },
+  "app/page.tsx -> @/components/views/WorklogsView": {
+    "id": 3373,
+    "files": [
+      "static/chunks/373.a1fb4c0f95875ef4.js"
+    ]
+  }
+}

package/ui/.next/required-server-files.json

@@ -335,6 +335,8 @@
     ".next/server/functions-config-manifest.json",
     ".next/server/middleware-manifest.json",
     ".next/server/middleware-build-manifest.js",
+    ".next/server/middleware-react-loadable-manifest.js",
+    ".next/react-loadable-manifest.json",
     ".next/server/app-paths-manifest.json",
     ".next/app-path-routes-manifest.json",
     ".next/server/server-reference-manifest.js",