create-workframe 0.1.10 → 0.1.12

package/workframe-api/server.py

@@ -10,6 +10,7 @@ from __future__ import annotations
 
 import base64
 import hashlib
+import hmac
 import json
 import mimetypes
 import os
@@ -36,7 +37,8 @@ from pathlib import Path
 from typing import Any, Iterator
 
 from email_sender import APP_BASE_URL, send_branded_invite_email, send_email, send_verification_email
-import install_api
+import profile_config_yaml
+import route_registry
 import stack_config
 import site_meta
 import google_auth
@@ -50,6 +52,7 @@ import concierge
 import llm_error_glossary
 import openrouter_catalog
 import updates as stack_updates
+import install_api
 
 HERMES_DATA = Path(os.environ.get("HERMES_DATA", "/opt/data"))
 WORKSPACE = Path(os.environ.get("WORKSPACE", "/workspace"))
@@ -197,6 +200,12 @@ DEPLOYMENT_MODE = _resolve_deployment_mode()
 # ponytail: docker exec per bind was ~10s; cache gateway registration briefly.
 _gateway_registered_cache: dict[str, tuple[bool, float]] = {}
 _GATEWAY_REG_TTL_SEC = 45.0
+_profile_health_cache: dict[str, tuple[bool, float]] = {}
+_PROFILE_HEALTH_TTL_SEC = 8.0
+_user_llm_picker_cache: dict[str, tuple[frozenset[str], float]] = {}
+_USER_LLM_PICKER_TTL_SEC = 5.0
+_session_info_cache: dict[str, tuple[dict[str, Any], float]] = {}
+_SESSION_INFO_TTL_SEC = 5.0
 
 
 def _install_window_open() -> bool:
@@ -443,7 +452,7 @@ def _check_auth(request_handler) -> bool:
     auth_header = request_handler.headers.get("Authorization", "")
     if auth_header.startswith("Bearer "):
         token = _get_auth_token()
-        if auth_header[7:].strip() == token:
+        if token and hmac.compare_digest(auth_header[7:].strip(), token):
             request_handler.auth_user = "service"
             request_handler.auth_role = "owner"  # type: ignore[attr-defined]
             return True
@@ -782,40 +791,29 @@ _gateway_lifecycle_lock = threading.Lock()
 # Auth session helpers
 # ---------------------------------------------------------------------------
 
-# Routes that are public only for GET (POST still needs session)
-GET_PUBLIC_ROUTES = {
-    "/api/files/read",
-    "/api/files/raw",
-    "/api/files/tree",
-    "/api/files/list",
-    "/api/files/state",
-    "/api/board",
-    "/api/content",
-    "/api/content/get",
-    "/api/meta",
-    "/api/agents",
-    "/api/snapshot",
-    "/api/health",
-    "/api/hermes/usage",
-    "/api/hermes/profile",
-    "/api/hermes/debug",
-    "/api/hermes/insights",
-    "/api/hermes/gquota",
-    "/api/hermes/models",
-    "/api/hermes/skills",
-    "/api/hermes/commands",
-    "/api/routes",
-    "/api/chat/session",
-    "/api/chat/resolve",
-    "/api/chat/messages",
-    "/api/profiles",
-    "/api/setup/status",
-    "/api/install/status",
-    "/api/public/site-meta",
-    "/api/public/link-preview",
-    "/api/public/manifest.webmanifest",
-    "/api/auth/google/callback",
-}
+# Route auth tiers live in route_registry.py (WF-037).
+
+
+def _deployment_allows_sessionless_data_get(
+    *,
+    deployment_mode: str | None = None,
+    dev_local_unsafe: bool | None = None,
+) -> bool:
+    mode = deployment_mode if deployment_mode is not None else _resolve_deployment_mode()
+    dev = DEV_LOCAL_UNSAFE if dev_local_unsafe is None else dev_local_unsafe
+    return route_registry.deployment_allows_sessionless_data_get(mode, dev_local_unsafe=dev)
+
+
+def _sessionless_get_allowed(
+    path: str,
+    *,
+    deployment_mode: str | None = None,
+    dev_local_unsafe: bool | None = None,
+) -> bool:
+    mode = deployment_mode if deployment_mode is not None else _resolve_deployment_mode()
+    dev = DEV_LOCAL_UNSAFE if dev_local_unsafe is None else dev_local_unsafe
+    return route_registry.sessionless_get_allowed(path, deployment_mode=mode, dev_local_unsafe=dev)
+
 
 def _is_public_get(path: str) -> bool:
     """Return True if this GET path is public (no session needed)."""
@@ -823,9 +821,7 @@ def _is_public_get(path: str) -> bool:
         return True
     if path.startswith("/static/") or path.startswith("/assets/"):
         return True
-    if path.startswith("/api/public/branding/"):
-        return True
-    return path in GET_PUBLIC_ROUTES
+    return _sessionless_get_allowed(path)
 
 
 def _cookie_session_id(handler: BaseHTTPRequestHandler) -> str:
@@ -851,85 +847,27 @@ def _session_id_from_request(handler: BaseHTTPRequestHandler) -> str:
 
 
 def _auth_check(handler: BaseHTTPRequestHandler) -> bool:
-    """Return True if the request should be allowed through."""
+    """Return True if the request should be allowed through (WF-037 route_registry)."""
     path = urllib.parse.urlparse(handler.path).path
     method = handler.command
     sid = _session_id_from_request(handler)
 
-    if method == "GET" and path == "/api/auth/hermes-dashboard-gate":
-        if sid:
-            session_info = _zk.validate_session_token(sid)
-            if session_info:
-                _apply_session_user(handler, session_info["user_id"])
-        return True
-
-    if DEV_LOCAL_UNSAFE:
-        # Still validate session if present, to populate auth_user
-        if sid:
-            session_info = _zk.validate_session_token(sid)
-            if session_info:
-                _apply_session_user(handler, session_info["user_id"])
-        return True
-
-    # OPTIONS (CORS preflight) — always allow
-    if method == "OPTIONS":
-        return True
-
-    # GET public routes — still attach session user when cookie/header present
-    # (e.g. /api/hermes/models needs auth_user for per-user provider detection).
-    if method == "GET" and _is_public_get(path):
-        if sid:
-            session_info = _zk.validate_session_token(sid)
-            if session_info:
-                _apply_session_user(handler, session_info["user_id"])
-        return True
-
-    # POST auth endpoints (start/verify/logout/refresh) are public
-    if method == "POST" and path in (
-        "/api/auth/start",
-        "/api/auth/verify",
-        "/api/auth/logout",
-        "/api/auth/refresh",
-        "/api/setup",
-    ):
-        return True
-
-    if method == "POST" and path in (
-        "/api/auth/google/start",
-        "/api/auth/local-bootstrap",
-    ):
-        return True
-
-    if _install_window_open() and method == "POST" and path in (
-        "/api/install/email/test",
-        "/api/install/complete",
-        "/api/install/url/test",
-        "/api/install/setup-https",
-    ):
-        # ponytail: install/complete still needs auth_user in trusted_team — populate when session present
-        if sid:
-            session_info = _zk.validate_session_token(sid)
-            if session_info:
-                _apply_session_user(handler, session_info["user_id"])
-        return True
-
-    if _install_window_open() and method in ("GET", "PATCH") and path == "/api/install/stack":
-        return True
-
-    if _install_window_open() and method == "GET" and path in (
-        "/api/install/publish-hints",
-        "/api/install/url/test",
-    ):
-        return True
-
-    # Everything else needs a valid session
-    if not sid:
-        return False
-    session_info = _zk.validate_session_token(sid)
-    if not session_info:
-        return False
-    _apply_session_user(handler, session_info["user_id"])
-    return True
+    def _validate(sid_token: str):
+        return _zk.validate_session_token(sid_token)
+
+    def _attach(user_id: str) -> None:
+        _apply_session_user(handler, user_id)
+
+    return route_registry.authorize_request(
+        method,
+        path,
+        sid,
+        deployment_mode=_resolve_deployment_mode(),
+        dev_local_unsafe=DEV_LOCAL_UNSAFE,
+        install_window_open=_install_window_open(),
+        validate_session=_validate,
+        attach_user=_attach,
+    )
 
 
 def _workspace_role_for_user(user_id: str) -> str:
@@ -2417,12 +2355,15 @@ def _sync_oauth_llm_to_profile(profile: str, user_id: str, provider: str) -> boo
     hermes_auth_id = _hermes_auth_id_for_spec(spec)
     if not _hermes_oauth_tokens_present(user_id, hermes_auth_id):
         return False
+    prof = resolve_hermes_profile(profile)
+    auth = _load_profile_auth_json(prof)
+    if _extract_oauth_block_from_auth(auth, hermes_auth_id):
+        # ponytail: steady-state turns — skip user auth read when profile already has oauth
+        return False
     user_auth = _load_user_hermes_auth(user_id)
     if not isinstance(user_auth, dict):
         return False
-    prof = resolve_hermes_profile(profile)
     auth_path = _profile_dir(prof) / "auth.json"
-    auth = _load_profile_auth_json(prof)
     if not _merge_oauth_auth_into_profile(auth, user_auth, hermes_auth_id):
         return False
     auth["version"] = 1
@@ -5107,12 +5048,32 @@ def bootstrap_agent_dm_lane(
     model_id = str(model or "").strip()
     if model_id:
         try:
-            code, out = _gateway_exec(runtime, ["model", model_id])
+            applied = hermes_model_set(runtime, model_id, user_id, workspace_id)
             steps.append(
-                {"step": "set_runtime_model", "ok": code == 0, "model": model_id, "output": out.strip()},
+                {
+                    "step": "set_runtime_model",
+                    "ok": bool(applied.get("ok")),
+                    "model": model_id,
+                    **({"error": applied.get("error")} if not applied.get("ok") else {}),
+                },
             )
+            if not applied.get("ok"):
+                return {
+                    "ok": False,
+                    "template": template,
+                    "runtime": runtime,
+                    "steps": steps,
+                    "error": str(applied.get("error") or "set_runtime_model_failed"),
+                }
         except Exception as exc:
             steps.append({"step": "set_runtime_model", "ok": False, "error": str(exc)})
+            return {
+                "ok": False,
+                "template": template,
+                "runtime": runtime,
+                "steps": steps,
+                "error": str(exc),
+            }
     else:
         try:
             _bootstrap_profile_providers(runtime, user_id, workspace_id)
@@ -6025,6 +5986,25 @@ def _invalidate_gateway_registered_cache(runtime: str = "") -> None:
         _gateway_registered_cache.clear()
 
 
+def _invalidate_profile_health_cache(profile: str = "") -> None:
+    if profile:
+        _profile_health_cache.pop(safe_profile_slug(profile), None)
+    else:
+        _profile_health_cache.clear()
+
+
+def _invalidate_session_info_cache(profile: str = "", session_id: str = "") -> None:
+    if profile and session_id:
+        _session_info_cache.pop(f"{safe_profile_slug(profile)}:{session_id}", None)
+    elif profile:
+        prefix = f"{safe_profile_slug(profile)}:"
+        for key in list(_session_info_cache):
+            if key.startswith(prefix):
+                _session_info_cache.pop(key, None)
+    else:
+        _session_info_cache.clear()
+
+
 def _is_user_credential_home_slug(slug: str) -> bool:
     """UUID dirs under profiles/ hold per-user keys — not Hermes agent profiles."""
     return bool(_AGENT_PROFILE_UUID_RE.fullmatch(str(slug or "").strip()))
@@ -6207,7 +6187,7 @@ def ensure_runtime_profile(
         if not _profile_toolsets_ready(runtime, _chat_toolsets_for_profile(runtime)):
             _ensure_profile_toolsets(runtime)
         _ensure_profile_terminal_cwd(runtime)
-        _sync_runtime_model_from_template(runtime, template)
+        # ponytail: do not re-sync template model on every bind — destroys per-user reconcile
         return
     _purge_runtime_profile(runtime)
     _register_runtime_profile(runtime, template)
@@ -10761,15 +10741,23 @@ def _latest_session_id(profile: str) -> str:
 
 
 def _session_info(profile: str, session_id: str) -> dict[str, Any]:
-    db = _profile_dir(profile) / "state.db"
+    sid = str(session_id or "").strip()
+    prof = safe_profile_slug(str(profile or "").strip())
+    cache_key = f"{prof}:{sid}"
+    now = time.monotonic()
+    cached = _session_info_cache.get(cache_key)
+    if cached and now - cached[1] < _SESSION_INFO_TTL_SEC:
+        return dict(cached[0])
+    empty: dict[str, Any] = {
+        "session_id": session_id,
+        "title": "",
+        "active": False,
+        "message_count": 0,
+    }
+    db = _profile_dir(prof) / "state.db"
     conn = _ro_sqlite_live(db)
     if not conn:
-        return {
-            "session_id": session_id,
-            "title": "",
-            "active": False,
-            "message_count": 0,
-        }
+        return empty
     try:
         row = conn.execute(
             """
@@ -10779,26 +10767,20 @@ def _session_info(profile: str, session_id: str) -> dict[str, Any]:
             (session_id,),
         ).fetchone()
         if not row:
-            return {
-                "session_id": session_id,
-                "title": "",
-                "active": False,
-                "message_count": 0,
-            }
-        return {
+            _session_info_cache[cache_key] = (empty, now)
+            return empty
+        result = {
             "session_id": str(row["id"]),
             "title": (row["title"] or "").strip(),
             "active": row["ended_at"] is None,
             "message_count": int(row["message_count"] or 0),
             "started_at": _iso_from_unix(row["started_at"]),
         }
+        _session_info_cache[cache_key] = (result, now)
+        return result
     except sqlite3.Error:
-        return {
-            "session_id": session_id,
-            "title": "",
-            "active": False,
-            "message_count": 0,
-        }
+        _session_info_cache[cache_key] = (empty, now)
+        return empty
     finally:
         conn.close()
 
@@ -11368,48 +11350,7 @@ def _set_profile_model_base_url(profile: str, base_url: str) -> tuple[bool, str]
     if not base_url:
         return False, "base_url required"
     try:
-        raw = config_path.read_text(encoding="utf-8")
-    except OSError as exc:
-        return False, f"read failed: {exc}"
-    lines = raw.splitlines(keepends=True)
-    out: list[str] = []
-    in_model = False
-    wrote = False
-    for line in lines:
-        stripped = line.lstrip()
-        if stripped.startswith("model:"):
-            if not in_model:
-                in_model = True
-                rest = stripped.split(":", 1)[1].strip().strip("'\"")
-                if rest:
-                    out.append("model:\n")
-                    out.append(f"  default: {rest}\n")
-                else:
-                    out.append("model:\n")
-            continue
-        if in_model and stripped and not line.startswith((" ", "\t", "#")):
-            if not wrote:
-                out.append(f"  base_url: {base_url}\n")
-                wrote = True
-            in_model = False
-        if in_model and stripped.startswith("base_url:"):
-            out.append(f"  base_url: {base_url}\n")
-            wrote = True
-            continue
-        out.append(line)
-    if not wrote:
-        rebuilt: list[str] = []
-        inserted = False
-        for line in out:
-            rebuilt.append(line)
-            if not inserted and line.lstrip().startswith("model:"):
-                rebuilt.append(f"  base_url: {base_url}\n")
-                inserted = True
-        if not inserted:
-            rebuilt.insert(0, f"model:\n  base_url: {base_url}\n")
-        out = rebuilt
-    try:
-        config_path.write_text("".join(out), encoding="utf-8")
+        profile_config_yaml.update_model_surface(config_path, base_url=base_url)
     except OSError as exc:
         return False, f"write failed: {exc}"
     return True, ""
@@ -11457,73 +11398,38 @@ def _coalesce_profile_model_yaml(profile: str) -> None:
     model_headers = sum(
         1 for line in lines if line.lstrip().startswith("model:") and not line.startswith((" ", "\t"))
     )
-    if model_headers <= 1:
+    needs_coalesce = model_headers > 1
+    if not needs_coalesce:
+        in_model = False
+        for line in lines:
+            stripped = line.lstrip()
+            indent = len(line) - len(stripped)
+            if indent == 0 and stripped.startswith("model:"):
+                in_model = True
+                continue
+            if indent == 0 and stripped:
+                in_model = False
+            if in_model and indent == 2 and stripped.startswith("- "):
+                needs_coalesce = True
+                break
+    if not needs_coalesce:
         return
     block = _read_model_block(profile)
-    api_key_line = ""
-    for line in lines:
-        stripped = line.lstrip()
-        if stripped.startswith("api_key:"):
-            api_key_line = line if line.endswith("\n") else f"{line}\n"
-    out: list[str] = []
-    skipping_model = False
-    skipping_fallback = False
-    for line in lines:
-        stripped = line.lstrip()
-        indent = len(line) - len(stripped)
-        if indent == 0 and stripped.startswith("model:"):
-            skipping_model = True
-            skipping_fallback = False
-            continue
-        if indent == 0 and stripped.startswith("fallback_providers:"):
-            skipping_fallback = True
-            skipping_model = False
-            continue
-        if skipping_model:
-            if indent == 0 and stripped:
-                if stripped.startswith("- "):
-                    continue
-                if not stripped.startswith("fallback_providers:"):
-                    skipping_model = False
-                else:
-                    continue
-            else:
-                continue
-        if skipping_fallback:
-            if indent == 0 and stripped and not stripped.startswith("fallback_providers"):
-                skipping_fallback = False
-            else:
-                continue
-        out.append(line)
-    merged: list[str] = ["model:\n"]
     default = str(block.get("default") or HERMES_DEFAULT_PRIMARY).strip()
-    merged.append(f"  default: {default}\n")
     provider = str(block.get("provider") or "").strip()
-    if provider:
-        merged.append(f"  provider: {provider}\n")
     base_url = str(block.get("base_url") or "").strip()
-    if base_url:
-        merged.append(f"  base_url: {base_url}\n")
-    if api_key_line:
-        merged.append(api_key_line if api_key_line.startswith("  ") else f"  {api_key_line.lstrip()}")
+    api_key = str(block.get("api_key") or "").strip()
     chain = block.get("fallback_chain") if isinstance(block.get("fallback_chain"), list) else []
-    if chain:
-        merged.append("fallback_providers:\n")
-        for entry in chain:
-            prov = str(entry.get("provider", "")).strip()
-            model = str(entry.get("model", "")).strip()
-            if prov and model:
-                merged.append(f"  - provider: {prov}\n")
-                merged.append(f"    model: {model}\n")
-    if out and not out[0].startswith("model:"):
-        insert_at = 0
-        while insert_at < len(out) and (not out[insert_at].strip() or out[insert_at].lstrip().startswith("#")):
-            insert_at += 1
-        out[insert_at:insert_at] = merged
-    else:
-        out = merged + out
     try:
-        config_path.write_text("".join(out), encoding="utf-8")
+        profile_config_yaml.update_model_surface(
+            config_path,
+            default=default,
+            provider=provider or None,
+            base_url=base_url or None,
+            api_key=api_key or None,
+            fallback_chain=chain,
+            coalesce=True,
+        )
     except OSError:
         return
 
@@ -11665,17 +11571,48 @@ def _read_config_model_api_key(profile: str) -> str:
     return str(_read_model_block(profile).get("api_key") or "").strip()
 
 
-def _restart_runtime_profile_gateway(profile: str) -> None:
-    """Hermes api_server caches config.yaml — reload after lease rotation."""
+def _reload_runtime_profile_gateway(profile: str, *, wait_healthy: bool = True) -> None:
+    """Reload Hermes after config.yaml change — gateway restart before stop+start."""
     prof = resolve_hermes_profile(profile)
     if not _is_runtime_profile_slug(prof) or prof == _primary_profile():
         return
     with _gateway_lifecycle_lock:
+        if _profile_api_healthy(prof, timeout=0.5, use_cache=False):
+            code, _out = _gateway_exec(prof, ["gateway", "restart"])
+            if code == 0:
+                _invalidate_profile_health_cache(prof)
+                if wait_healthy:
+                    _wait_profile_api_healthy(prof, attempts=48, delay=0.25)
+                return
+        _invalidate_profile_health_cache(prof)
         try:
             profile_gateway_lifecycle(prof, "stop", bootstrap_providers=False)
         except ValueError:
             pass
         profile_gateway_lifecycle(prof, "start", bootstrap_providers=False)
+        if wait_healthy:
+            _wait_profile_api_healthy(prof)
+
+
+def _schedule_gateway_reload(profile: str) -> None:
+    """ponytail: model-save hot path — yaml is sync; reload async (~7s, not ~45s)."""
+    prof = resolve_hermes_profile(profile)
+    if not _profile_api_healthy(prof, timeout=0.5, use_cache=False):
+        return  # cold start on next bind via ensure_profile_api
+
+    def _run() -> None:
+        try:
+            with _gateway_lifecycle_lock:
+                _reload_runtime_profile_gateway(prof, wait_healthy=False)
+        except Exception as exc:  # noqa: BLE001
+            print(f"[workframe-api] gateway reload failed for {prof}: {exc}")
+
+    threading.Thread(target=_run, name=f"gw-reload-{prof}", daemon=True).start()
+
+
+def _restart_runtime_profile_gateway(profile: str) -> None:
+    """Hermes api_server caches config.yaml — reload after lease rotation."""
+    _reload_runtime_profile_gateway(profile, wait_healthy=True)
 
 
 def _sync_profile_model_api_key(profile: str, api_key: str) -> None:
@@ -11709,12 +11646,13 @@ def _apply_turn_credential_lease(
     oauth_spec = _oauth_llm_provider_spec(provider)
     if oauth_spec and str(resolved.get("credential_type") or "") == "oauth":
         _sync_oauth_llm_to_profile(prof, user_id, provider)
-        current_model = str(_read_model_from_config(prof)[1] or "").strip()
-        if not _resolve_billing_provider_for_model(current_model, {provider}):
-            current_model = str(
-                (PROVIDER_MVP_MODELS.get(provider) or {}).get("primary") or current_model
-            ).strip()
-        _apply_model_for_billing_provider(prof, provider, current_model, user_id)
+        if not _profile_routing_matches_billing(prof, provider):
+            current_model = str(_read_model_from_config(prof)[1] or "").strip()
+            if not _resolve_billing_provider_for_model(current_model, {provider}):
+                current_model = str(
+                    (PROVIDER_MVP_MODELS.get(provider) or {}).get("primary") or current_model
+                ).strip()
+            _apply_model_for_billing_provider(prof, provider, current_model, user_id)
         return ""
     binding_id = str(
         resolved.get("credential_binding_id") or resolved.get("credential_id") or ""
@@ -12115,10 +12053,13 @@ def profile_gateway_lifecycle(profile: str, action: str, *, bootstrap_providers:
     prof = resolve_hermes_profile(profile)
     if action in {"start", "stop", "disable"}:
         _invalidate_gateway_registered_cache(prof)
+        _invalidate_profile_health_cache(prof)
     if action not in {"start", "stop", "status", "disable"}:
         raise ValueError("invalid action")
     port = _profile_api_port(prof)
     if SECURE_MODE and prof != _primary_profile() and action in {"start", "stop", "disable"}:
+        if action == "start":
+            _normalize_profile_config_yaml(prof)
         return _supervisor_profile_lifecycle(prof, action)
     if prof == _primary_profile():
         if action == "disable":
@@ -12557,14 +12498,18 @@ def _is_transient_profile_api_error(exc: Exception) -> bool:
     return any(token in reason for token in ("connection refused", "timed out", "temporarily unavailable"))
 
 
-def _profile_api_healthy(profile: str, timeout: float = 1.5) -> bool:
+def _profile_api_healthy(profile: str, timeout: float = 1.5, *, use_cache: bool = True) -> bool:
     try:
         prof = resolve_hermes_profile(profile)
     except ValueError:
         return False
+    wait = max(1.0, float(timeout))
+    if use_cache and wait >= 1.0:
+        cached = _profile_health_cache.get(prof)
+        if cached and time.monotonic() - cached[1] < _PROFILE_HEALTH_TTL_SEC:
+            return cached[0]
     port = _profile_api_port(prof)
     key = _profile_api_key(prof)
-    wait = max(1.0, float(timeout))
     url = f"http://gateway:{port}/v1/health"
     req = urllib.request.Request(
         url,
@@ -12573,9 +12518,12 @@ def _profile_api_healthy(profile: str, timeout: float = 1.5) -> bool:
     )
     try:
         with urllib.request.urlopen(req, timeout=wait) as resp:
-            return int(resp.status) < 300
+            ok = int(resp.status) < 300
     except Exception:  # noqa: BLE001
-        return False
+        ok = False
+    if use_cache and wait >= 1.0:
+        _profile_health_cache[prof] = (ok, time.monotonic())
+    return ok
 
 
 def _wait_profile_api_healthy(profile: str, attempts: int = 60, delay: float = 0.5) -> bool:
@@ -12680,11 +12628,17 @@ def _user_llm_providers_for_picker(user_id: str) -> set[str]:
     user = str(user_id or "").strip()
     if not user:
         return set()
-    return {
+    now = time.monotonic()
+    cached = _user_llm_picker_cache.get(user)
+    if cached and now - cached[1] < _USER_LLM_PICKER_TTL_SEC:
+        return set(cached[0])
+    connected = frozenset(
         str(spec["id"]).lower()
         for spec in PROVIDER_CONNECT_CATALOG
         if str(spec.get("category") or "") == "llm" and _user_provider_connected(user, spec)
-    }
+    )
+    _user_llm_picker_cache[user] = (connected, now)
+    return set(connected)
 
 
 def _user_has_llm_provider(user_id: str) -> bool:
@@ -12747,11 +12701,13 @@ def _overlay_chat_llm_env(
 
 
 def _resolve_models_profile(profile: str) -> str:
-    """Template profile slug for model picker reads — never per-user runtime u-*."""
+    """Hermes profile slug for model picker reads. Use runtime u-* when it exists on disk."""
     raw = str(profile or "").strip()
     if not raw:
         return _primary_profile()
     slug = safe_profile_slug(raw)
+    if _is_runtime_profile_slug(slug) and _runtime_profile_on_disk(slug):
+        return slug
     if _is_runtime_profile_slug(slug):
         return resolve_validated_profile(_runtime_template_slug(slug))
     return resolve_validated_profile(slug)
@@ -12847,10 +12803,11 @@ def _llm_billing_provider(
     *,
     user_id: str = "",
     workspace_id: str = "",
+    block: dict[str, Any] | None = None,
 ) -> str:
     """Map Hermes routing provider (often custom for proxy) to vault/billing provider id."""
     prof = resolve_hermes_profile(profile)
-    block = _read_model_block(prof)
+    block = block if block is not None else _read_model_block(prof)
     cfg_provider = str(block.get("provider") or "").strip().lower()
     billing_cfg = _billing_provider_id_from_hermes_config(cfg_provider)
     user = str(user_id or "").strip()
@@ -12873,6 +12830,28 @@ def _profile_llm_proxy_matches_billing(profile: str, billing_provider: str) -> b
     return bool(base) and base == _llm_proxy_base_url(billing_provider)
 
 
+def _profile_routing_matches_billing(
+    prof: str,
+    billing: str,
+    *,
+    block: dict[str, Any] | None = None,
+) -> bool:
+    """True when config.yaml already routes through the requested billing provider."""
+    billing = str(billing or "").strip().lower()
+    if not billing:
+        return False
+    block = block if block is not None else _read_model_block(prof)
+    model = str(block.get("default") or "").strip()
+    if not model:
+        return False
+    cfg = str(block.get("provider") or "").strip().lower()
+    if _oauth_llm_provider_spec(billing):
+        return cfg == _hermes_config_provider_id(billing).lower()
+    if cfg != "custom":
+        return False
+    return _profile_llm_proxy_matches_billing(prof, billing)
+
+
 def _reconcile_profile_llm_for_user(
     profile: str,
     user_id: str,
@@ -12885,20 +12864,44 @@ def _reconcile_profile_llm_for_user(
     if not user:
         return False
     prof = resolve_hermes_profile(profile)
-    billing = _llm_billing_provider(prof, user_id=user, workspace_id=workspace_id)
+    block = _read_model_block(prof)
+    model = str(block.get("default") or "").strip()
+    if model:
+        cfg = str(block.get("provider") or "").strip().lower()
+        quick_billing = _billing_provider_id_from_hermes_config(cfg)
+        # Direct oauth routing only — custom proxy may still need rebilling to user's provider.
+        if quick_billing and cfg != "custom" and _profile_routing_matches_billing(
+            prof, quick_billing, block=block,
+        ):
+            return False
+    connected = _user_llm_providers_for_picker(user)
+    current_model = model
     prefer = str(prefer_provider or "").strip().lower()
-    if prefer and _user_can_use_llm(user, workspace_id, prefer):
+    model_billing = (
+        _resolve_billing_provider_for_model(current_model, connected, prefer=prefer)
+        if current_model
+        else ""
+    )
+    if model_billing and _user_can_use_llm(user, workspace_id, model_billing):
+        billing = model_billing
+    elif prefer and _user_can_use_llm(user, workspace_id, prefer):
         billing = prefer
-    elif not _user_can_use_llm(user, workspace_id, billing):
-        connected = sorted(_user_llm_providers_for_picker(user))
-        if not connected:
-            return False
-        billing = connected[0]
+    else:
+        billing = _llm_billing_provider(prof, user_id=user, workspace_id=workspace_id)
+        if not _user_can_use_llm(user, workspace_id, billing):
+            connected_sorted = sorted(connected)
+            if not connected_sorted:
+                return False
+            billing = connected_sorted[0]
+    if _profile_routing_matches_billing(prof, billing):
+        return False
     if _oauth_llm_provider_spec(billing) and _user_can_use_llm(user, workspace_id, billing):
         current = str(_read_model_from_config(prof)[1] or "").strip()
-        if not _resolve_billing_provider_for_model(current, {billing}):
+        if not _resolve_billing_provider_for_model(current, {billing}, prefer=billing):
             current = str((PROVIDER_MVP_MODELS.get(billing) or {}).get("primary") or "")
         _apply_model_for_billing_provider(prof, billing, current, user_id=user)
+        if _is_runtime_profile_slug(prof):
+            _reload_runtime_profile_gateway(prof, wait_healthy=True)
         return True
     if _user_can_use_llm(user, workspace_id, billing) and _profile_llm_proxy_matches_billing(prof, billing):
         return False
@@ -12906,39 +12909,29 @@ def _reconcile_profile_llm_for_user(
     block = _read_model_block(prof)
     if _is_runtime_profile_slug(prof) or str(block.get("provider") or "").strip().lower() == "custom":
         _ensure_profile_llm_proxy(prof, billing)
+    if changed and _is_runtime_profile_slug(prof):
+        _reload_runtime_profile_gateway(prof, wait_healthy=True)
     return changed
 
 
-def _bootstrap_profile_providers(profile: str, user_id: str = "", workspace_id: str = "") -> bool:
-    """Seed profile auth + MVP model config from user, workspace, or primary stack."""
+def _ensure_profile_auth_pool(profile: str, user_id: str = "", workspace_id: str = "") -> bool:
+    """Sync auth.json credential pool — does not mutate model yaml (safe on GET /models)."""
     prof = resolve_hermes_profile(profile)
     if prof == _primary_profile():
         return False
-
-    changed = False
     if _is_runtime_profile_slug(prof):
-        changed = _prepare_runtime_profile_credentials(prof, user_id, workspace_id) or False
+        _strip_profile_llm_env(prof)
+        _strip_profile_action_env(prof)
     else:
-        changed = _strip_profile_llm_env(prof) or False
-        changed = _strip_profile_action_env(prof) or changed
-        changed = _sync_profile_provider_env(prof, user_id, workspace_id) or changed
-
-    provider, model_name = _read_model_from_config(prof)
-    llm_provider = _llm_billing_provider(prof, provider or "")
-    if not str(model_name or "").strip():
-        changed = _apply_mvp_model_for_provider(prof, llm_provider) or changed
-        if _is_runtime_profile_slug(prof):
-            _ensure_profile_llm_proxy(prof, llm_provider)
-    elif not str(_read_model_from_config(prof)[0] or "").strip():
-        ok_provider, _ = _set_profile_model_provider(prof, llm_provider)
-        changed = ok_provider or changed
-        if _is_runtime_profile_slug(prof):
-            _ensure_profile_llm_proxy(prof, llm_provider)
+        _strip_profile_llm_env(prof)
+        _strip_profile_action_env(prof)
+        _sync_profile_provider_env(prof, user_id, workspace_id)
 
+    llm_provider = _llm_billing_provider(prof, user_id=user_id, workspace_id=workspace_id)
     auth_path = _profile_dir(prof) / "auth.json"
     auth = _load_profile_auth_json(prof)
     if _provider_pool_has_entries(auth, llm_provider):
-        return changed
+        return False
 
     user = str(user_id or "").strip()
     llm_spec = _catalog_provider_for_llm(llm_provider)
@@ -12952,7 +12945,7 @@ def _bootstrap_profile_providers(profile: str, user_id: str = "", workspace_id:
 
     if _is_runtime_profile_slug(prof):
         if not user or not _user_can_use_llm(user, workspace_id, llm_provider):
-            return changed
+            return False
         env_var = _provider_env_var(llm_provider)
         template = _runtime_provider_pool_entry(llm_provider, env_var)
     else:
@@ -12963,7 +12956,7 @@ def _bootstrap_profile_providers(profile: str, user_id: str = "", workspace_id:
             user_only=_provider_user_only(llm_provider),
         )
         if not resolved:
-            return changed
+            return False
 
         ref = str(resolved.get("credential_ref") or "")
         env_var = str(resolved.get("env_var") or "") or (ref[4:] if ref.startswith("env:") else _provider_env_var(llm_provider))
@@ -12983,6 +12976,32 @@ def _bootstrap_profile_providers(profile: str, user_id: str = "", workspace_id:
     return True
 
 
+def _bootstrap_profile_providers(profile: str, user_id: str = "", workspace_id: str = "") -> bool:
+    """Seed profile auth + MVP model config from user, workspace, or primary stack."""
+    prof = resolve_hermes_profile(profile)
+    if prof == _primary_profile():
+        return False
+
+    changed = _ensure_profile_auth_pool(prof, user_id, workspace_id)
+
+    provider, model_name = _read_model_from_config(prof)
+    llm_provider = _llm_billing_provider(prof, provider or "")
+    if not str(model_name or "").strip():
+        changed = _apply_mvp_model_for_provider(prof, llm_provider) or changed
+        if _is_runtime_profile_slug(prof):
+            _ensure_profile_llm_proxy(prof, llm_provider)
+    elif not str(_read_model_from_config(prof)[0] or "").strip():
+        ok_provider, _ = _set_profile_model_provider(prof, llm_provider)
+        changed = ok_provider or changed
+        if _is_runtime_profile_slug(prof):
+            _ensure_profile_llm_proxy(prof, llm_provider)
+
+    if _is_runtime_profile_slug(prof):
+        _prepare_runtime_profile_credentials(prof, user_id, workspace_id)
+
+    return changed
+
+
 def ensure_profile_api(
     profile: str,
     user_id: str = "",
@@ -12995,6 +13014,20 @@ def ensure_profile_api(
     port = _profile_api_port(prof)
     if _profile_api_healthy(prof):
         return {"ok": True, "profile": prof, "api_port": port, "started": False}
+    # ponytail: gateway restart (~7s) before supervisor cold start (~37s).
+    if (
+        _is_runtime_profile_slug(prof)
+        and prof != _primary_profile()
+        and _runtime_profile_on_disk(prof)
+    ):
+        with _gateway_lifecycle_lock:
+            if _profile_api_healthy(prof, use_cache=False):
+                return {"ok": True, "profile": prof, "api_port": port, "started": False}
+            code, _out = _gateway_exec(prof, ["gateway", "restart"])
+            if code == 0:
+                _invalidate_profile_health_cache(prof)
+                if _wait_profile_api_healthy(prof, attempts=48, delay=0.25):
+                    return {"ok": True, "profile": prof, "api_port": port, "started": False}
     if prof == _primary_profile():
         ok, out, _port = _configure_profile_api(prof)
         if not ok:
@@ -13079,19 +13112,20 @@ def profile_chat_session(profile: str, payload: dict[str, Any], user_id: str = "
     hermes_prof = ""
     template_prof = ""
     agent_db_id = ""
+    room_conn: sqlite3.Connection | None = None
 
     if room_id:
         if not user_id:
             raise ValueError("room_id requires authenticated user")
-        conn = _workframe_db()
+        room_conn = _workframe_db()
         try:
-            room = conn.execute(
+            room = room_conn.execute(
                 "SELECT * FROM rooms WHERE id = ? AND deleted_at IS NULL",
                 (room_id,),
             ).fetchone()
             if not room:
                 raise ValueError("room_not_found")
-            if not _user_can_access_room(conn, room_id, user_id):
+            if not _user_can_access_room(room_conn, room_id, user_id):
                 raise ValueError("room_access_denied")
             if not workspace_id:
                 workspace_id = str(room["workspace_id"])
@@ -13105,30 +13139,36 @@ def profile_chat_session(profile: str, payload: dict[str, Any], user_id: str = "
                     hermes_prof = _resolve_chat_hermes_profile(
                         template_prof, user_id, room_id, workspace_id,
                     )
-                agent_row = _lookup_agent_profile(conn, workspace_id, template_prof)
+                agent_row = _lookup_agent_profile(room_conn, workspace_id, template_prof)
                 if not agent_row:
                     raise ValueError("agent_profile_not_found")
                 agent_db_id = str(agent_row["id"])
             else:
                 _room, template_prof, hermes_prof, agent_db_id, workspace_id = _resolve_room_agent_chat(
-                    conn, user_id, room_id,
+                    room_conn, user_id, room_id,
                 )
-        finally:
-            conn.close()
+        except Exception:
+            if room_conn is not None:
+                room_conn.close()
+            raise
     else:
         hermes_prof, template_prof = _resolve_bind_profile_arg(
             profile, user_id, "", workspace_id,
         )
     payer = user_id
-    if payer:
-        _reconcile_profile_llm_for_user(hermes_prof, payer, workspace_id)
-    llm_provider = _llm_billing_provider(hermes_prof, user_id=payer, workspace_id=workspace_id)
-    lifecycle = ensure_profile_api(hermes_prof, user_id, workspace_id)
+    model_block = _read_model_block(hermes_prof) if hermes_prof else {}
+    llm_provider = _llm_billing_provider(
+        hermes_prof, user_id=payer, workspace_id=workspace_id, block=model_block,
+    )
     llm_ready = _user_can_use_llm(payer, workspace_id, llm_provider) if payer else False
+    # ponytail: bind = session lookup only; gateway + billing reconcile happen on send/model-save.
+    api_port = _profile_api_port(hermes_prof) if hermes_prof else 0
+    lifecycle = {"ok": True, "profile": hermes_prof, "api_port": api_port, "started": False}
     session_extra = {"llm_ready": llm_ready, "has_llm_provider": llm_ready}
 
     if room_id:
-        conn = _workframe_db()
+        conn = room_conn if room_conn is not None else _workframe_db()
+        close_conn = room_conn is None
         try:
             existing_row = (
                 None
@@ -13137,13 +13177,14 @@ def profile_chat_session(profile: str, payload: dict[str, Any], user_id: str = "
             )
             if existing_row:
                 sid = str(existing_row["session_id"]).strip()
-                if not sid or not _session_exists(hermes_prof, sid):
+                if not sid:
                     existing_row = None
             if existing_row:
                 sid = str(existing_row["session_id"]).strip()
                 gateway_sid = str(existing_row["gateway_session_id"] or f"api:{hermes_prof}:{sid}").strip()
                 session_title = str(existing_row["title"] or _default_session_title(template_prof))
-                _ensure_hermes_session_title(hermes_prof, sid, session_title)
+                if _is_blank_session_title(str(existing_row["title"] or "")):
+                    _ensure_hermes_session_title(hermes_prof, sid, session_title)
                 _upsert_room_session(
                     conn,
                     room_id=room_id,
@@ -13162,6 +13203,11 @@ def profile_chat_session(profile: str, payload: dict[str, Any], user_id: str = "
                     sid,
                     gateway_sid,
                 )
+                display_title = (
+                    session_title
+                    if not _is_blank_session_title(session_title)
+                    else _resolved_session_title(hermes_prof, sid, session_title)
+                )
                 return {
                     "ok": True,
                     "profile": hermes_prof,
@@ -13169,7 +13215,7 @@ def profile_chat_session(profile: str, payload: dict[str, Any], user_id: str = "
                     "workspace_id": workspace_id,
                     "room_id": room_id,
                     "session_id": sid,
-                    "title": _resolved_session_title(hermes_prof, sid, session_title),
+                    "title": display_title,
                     "api_port": lifecycle["api_port"],
                     "created": False,
                     "resumed": str(existing_row["status"]) != "active",
@@ -13192,7 +13238,10 @@ def profile_chat_session(profile: str, payload: dict[str, Any], user_id: str = "
             )
             conn.commit()
         finally:
-            conn.close()
+            if close_conn:
+                conn.close()
+            elif room_conn is not None:
+                room_conn.close()
         _sync_lane_binding(
             hermes_prof,
             source_id,
@@ -13744,6 +13793,51 @@ def _emit_stream_chat_error(
         return
 
 
+def _open_profile_stream(
+    handler: BaseHTTPRequestHandler,
+    prof: str,
+    *,
+    model_used: str,
+    llm_provider: str,
+    api_port: int,
+) -> None:
+    """Flush SSE headers + run.started before blocking on gateway/model."""
+    handler.send_response(200)
+    handler.send_header("Content-Type", "text/event-stream; charset=utf-8")
+    handler.send_header("Cache-Control", "no-cache")
+    handler.send_header("Connection", "keep-alive")
+    handler.send_header("X-Workframe-Profile", prof)
+    handler.send_header("X-Workframe-Api-Port", str(api_port))
+    handler.end_headers()
+    handler.wfile.write(
+        (
+            "event: run.started\n"
+            f"data: {json.dumps({'text': 'Contacting model...', 'model': model_used, 'llm_provider': llm_provider})}\n\n"
+        ).encode("utf-8"),
+    )
+    handler.wfile.flush()
+
+
+def _emit_stream_error_body(
+    handler: BaseHTTPRequestHandler,
+    *,
+    entry: dict[str, Any] | None = None,
+    message: str = "",
+) -> None:
+    """Error/done frames when SSE headers were already sent."""
+    payload = llm_error_glossary.notice_payload(entry) if entry else {}
+    if not payload:
+        text = str(message or "").strip() or "Chat failed."
+        payload = {"error": text, "text": text, "message": text}
+    try:
+        body = json.dumps(payload)
+        handler.wfile.write(f"event: error\ndata: {body}\n\n".encode("utf-8"))
+        handler.wfile.write(b"event: done\ndata: {}\n\n")
+        handler.wfile.flush()
+    except (BrokenPipeError, ConnectionResetError, OSError):
+        return
+
+
 def _emit_stream_concierge(handler: BaseHTTPRequestHandler, entry: dict[str, Any]) -> None:
     """Deterministic assistant reply when LLM path is unavailable."""
     payload = llm_error_glossary.notice_payload(entry)
@@ -13802,10 +13896,10 @@ def stream_profile_chat(handler: BaseHTTPRequestHandler, profile: str, payload:
         raise ValueError("session_id required")
     if not text:
         raise ValueError("text required")
-    if _triggering_user:
-        _reconcile_profile_llm_for_user(prof, _triggering_user, _workspace_id)
-    llm_provider = _llm_billing_provider(prof, user_id=_triggering_user, workspace_id=_workspace_id)
     model_block = _read_model_block(prof)
+    llm_provider = _llm_billing_provider(
+        prof, user_id=_triggering_user, workspace_id=_workspace_id, block=model_block,
+    )
     model_used = str(model_block.get("default") or "").strip()
     llm_ready = bool(
         _triggering_user
@@ -13816,8 +13910,16 @@ def stream_profile_chat(handler: BaseHTTPRequestHandler, profile: str, payload:
         _log_llm_failure(handler, str(entry.get("code") or "no_llm_provider"), provider=llm_provider, profile=prof)
         _emit_stream_concierge(handler, entry)
         return
+    api_port = _profile_api_port(prof)
+    _open_profile_stream(
+        handler,
+        prof,
+        model_used=model_used,
+        llm_provider=llm_provider,
+        api_port=api_port,
+    )
     try:
-        lifecycle = ensure_profile_api(
+        ensure_profile_api(
             prof,
             _triggering_user,
             _workspace_id,
@@ -13833,11 +13935,11 @@ def stream_profile_chat(handler: BaseHTTPRequestHandler, profile: str, payload:
         if "no_llm_provider_for_user" in err_text:
             entry = concierge.respond(text, situation="no_provider")
             _log_llm_failure(handler, "no_llm_provider", provider=llm_provider, profile=prof)
-            _emit_stream_concierge(handler, entry)
+            _emit_stream_error_body(handler, entry=entry)
             return
         entry = llm_error_glossary.classify_exception_text(err_text)
         _log_llm_failure(handler, str(entry.get("code") or ""), provider=llm_provider, profile=prof)
-        _emit_stream_chat_error(handler, entry=entry)
+        _emit_stream_error_body(handler, entry=entry)
         return
     upstream_body = json.dumps(_profile_turn_payload(prof, text, _room_id)).encode("utf-8")
 
@@ -13857,8 +13959,7 @@ def stream_profile_chat(handler: BaseHTTPRequestHandler, profile: str, payload:
             except Exception:
                 pass
 
-    port = _profile_api_port(prof)
-    url = f"http://gateway:{port}/api/sessions/{urllib.parse.quote(session_id, safe='')}/chat/stream"
+    url = f"http://gateway:{api_port}/api/sessions/{urllib.parse.quote(session_id, safe='')}/chat/stream"
     headers = {
         "Authorization": f"Bearer {_profile_api_key(prof)}",
         "Content-Type": "application/json",
@@ -13872,25 +13973,15 @@ def stream_profile_chat(handler: BaseHTTPRequestHandler, profile: str, payload:
             data = json.loads(raw)
         except Exception:  # noqa: BLE001
             data = {"error": raw or f"upstream stream failed: {exc.code}"}
-        raise ValueError(f"session chat stream failed: {data}") from exc
+        entry = llm_error_glossary.classify_exception_text(str(data))
+        _emit_stream_error_body(handler, entry=entry)
+        return
     except OSError as exc:
-        raise ValueError(f"session chat stream failed: {exc}") from exc
+        entry = llm_error_glossary.classify_exception_text(str(exc))
+        _emit_stream_error_body(handler, entry=entry)
+        return
 
     try:
-        handler.send_response(200)
-        handler.send_header("Content-Type", "text/event-stream; charset=utf-8")
-        handler.send_header("Cache-Control", "no-cache")
-        handler.send_header("Connection", "keep-alive")
-        handler.send_header("X-Workframe-Profile", prof)
-        handler.send_header("X-Workframe-Api-Port", str(lifecycle["api_port"]))
-        handler.end_headers()
-        handler.wfile.write(
-            (
-                "event: run.started\n"
-                f"data: {json.dumps({'text': 'Contacting model...', 'model': model_used, 'llm_provider': llm_provider})}\n\n"
-            ).encode("utf-8")
-        )
-        handler.wfile.flush()
         buffer = b""
         saw_complete = False
         complete_text = ""
@@ -14819,7 +14910,7 @@ def _model_catalog_rows_for_provider(provider_id: str) -> list[dict[str, str]]:
         seen.add(mid)
         rows.append(
             {
-                "provider": label,
+                "provider": provider_key,
                 "billing_provider": provider_key,
                 "model": mid,
                 "label": row_label,
@@ -14860,21 +14951,105 @@ def _suggestions_for_connected_llm_providers(connected: set[str]) -> list[dict[s
     return out
 
 
-def _resolve_billing_provider_for_model(model_id: str, connected: set[str]) -> str:
+def _model_id_vendor_and_bare(model_id: str) -> tuple[str, str]:
+    """Split vendor/model ids (e.g. openai-codex/gpt-5.4-mini) into billing + bare model."""
+    mid = str(model_id or "").strip()
+    if "/" not in mid:
+        return "", mid
+    prefix, bare = mid.split("/", 1)
+    billing = _billing_provider_id_from_hermes_config(prefix)
+    return billing, bare.strip()
+
+
+def _persisted_model_id(model_id: str, billing: str) -> str:
+    billing = str(billing or "").strip().lower()
+    _, bare = _model_id_vendor_and_bare(model_id)
+    if _oauth_llm_provider_spec(billing) and bare:
+        return bare
+    return str(model_id or "").strip()
+
+
+def _apply_model_persisted(
+    profile: str,
+    billing: str,
+    model_id: str,
+    user_id: str = "",
+    *,
+    restart_gateway: bool = True,
+) -> tuple[bool, str]:
+    """Write model surface and verify default landed on disk before returning ok."""
+    prof = resolve_hermes_profile(profile)
+    billing = str(billing or "").strip().lower()
+    if billing:
+        if not _apply_model_for_billing_provider(prof, billing, model_id, user_id=user_id):
+            return False, "model apply failed"
+    else:
+        ok, err = _set_profile_model(prof, model_id)
+        if not ok:
+            return False, err or "model apply failed"
+    expected = _persisted_model_id(model_id, billing)
+    got = str(_parse_model_block_from_disk(prof).get("default") or "").strip()
+    if expected and got != expected:
+        return False, f"model not persisted (expected {expected}, got {got or 'empty'})"
+    if restart_gateway and _is_runtime_profile_slug(prof):
+        _reload_runtime_profile_gateway(prof, wait_healthy=True)
+    return True, ""
+
+
+def _mirror_template_model_to_runtime(
+    user_id: str,
+    template_slug: str,
+    billing: str,
+    model_id: str,
+) -> tuple[bool, str]:
+    """After a template model save, apply the same pick to the user's runtime profile."""
+    user = str(user_id or "").strip()
+    template = safe_profile_slug(template_slug)
+    if not user or _is_runtime_profile_slug(template):
+        return True, ""
+    runtime = _runtime_profile_slug(user, template)
+    if not _runtime_profile_on_disk(runtime):
+        return True, ""
+    return _apply_model_persisted(
+        runtime, billing, model_id, user_id=user, restart_gateway=False,
+    )
+
+
+def _resolve_billing_provider_for_model(
+    model_id: str,
+    connected: set[str],
+    *,
+    prefer: str = "",
+) -> str:
     mid = str(model_id or "").strip()
     if not mid or not connected:
         return ""
+    vendor, bare = _model_id_vendor_and_bare(mid)
+    if vendor and vendor in connected:
+        return vendor
+    match_ids = [mid]
+    if bare and bare not in match_ids:
+        match_ids.append(bare)
+    pref = str(prefer or "").strip().lower()
+    if pref and pref in connected:
+        for row in _model_catalog_rows_for_provider(pref):
+            row_model = str(row.get("model") or "").strip()
+            if row_model in match_ids:
+                return pref
     for provider_id in sorted(connected):
         for row in _model_catalog_rows_for_provider(provider_id):
-            if str(row.get("model") or "").strip() == mid:
+            row_model = str(row.get("model") or "").strip()
+            if row_model in match_ids:
                 return provider_id
-    low = mid.lower()
+    low = (bare or mid).lower()
     if low.startswith("gpt-") and "codex" in connected:
         return "codex"
     if low.startswith("gpt-") and "openai" in connected:
         return "openai"
     if "/" in mid and "openrouter" in connected:
-        return "openrouter"
+        prefix = mid.split("/", 1)[0].strip().lower()
+        if not _billing_provider_id_from_hermes_config(prefix):
+            return "openrouter"
     if low.startswith("claude") and "anthropic" in connected:
         return "anthropic"
     if "gemini" in low and "google" in connected:
@@ -14919,6 +15094,9 @@ def _apply_model_for_billing_provider(
     user_id: str = "",
 ) -> bool:
     billing = str(billing or "").strip().lower()
+    _, bare = _model_id_vendor_and_bare(model_id)
+    if _oauth_llm_provider_spec(billing) and bare:
+        model_id = bare
     ok, _ = _set_profile_model(profile, model_id)
     if not ok:
         return False
@@ -14929,7 +15107,9 @@ def _apply_model_for_billing_provider(
         _strip_profile_model_proxy_fields(profile)
         fallbacks = PROVIDER_MVP_MODELS.get(billing, {}).get("fallbacks") or []
         if isinstance(fallbacks, list):
-            _write_fallback_chain(profile, fallbacks)
+            chain = _read_model_block(profile).get("fallback_chain") or []
+            if not chain:
+                _write_fallback_chain(profile, fallbacks)
         user = str(user_id or "").strip()
         if user:
             _sync_oauth_llm_to_profile(profile, user, billing)
@@ -15087,50 +15267,14 @@ HERMES_MODEL_CATALOG: list[dict[str, str]] = [
 
 
 def _set_profile_model(profile: str, model_id: str) -> tuple[bool, str]:
-    """Update `model.default` in config.yaml. Minimal text rewrite — no pyyaml."""
+    """Update `model.default` in config.yaml via profile_config_yaml."""
     _normalize_profile_config_yaml(profile)
     try:
         config_path = _ensure_gateway_config_file(profile)
     except ValueError as exc:
         return False, str(exc)
     try:
-        raw = config_path.read_text(encoding="utf-8")
-    except OSError as exc:
-        return False, f"read failed: {exc}"
-
-    lines = raw.splitlines(keepends=True)
-    out: list[str] = []
-    in_model_block = False
-    wrote_default = False
-    for line in lines:
-        stripped = line.lstrip()
-        if stripped.startswith("model:"):
-            if not in_model_block:
-                in_model_block = True
-                rest = stripped.split(":", 1)[1].strip().strip("'\"")
-                if rest:
-                    out.append("model:\n")
-                    out.append(f"  default: {rest}\n")
-                else:
-                    out.append("model:\n")
-            continue
-        if in_model_block and stripped and not line.startswith((" ", "\t", "#")):
-            in_model_block = False
-        if in_model_block and stripped.startswith("default:"):
-            indent = line[: len(line) - len(stripped)]
-            out.append(f"{indent}default: {model_id}\n")
-            wrote_default = True
-            continue
-        out.append(line)
-
-    if not wrote_default:
-        # No model block existed. Prepend one.
-        if not raw.endswith("\n"):
-            out.insert(0, "\n")
-        out.insert(0, f"model:\n  default: {model_id}\n")
-
-    try:
-        config_path.write_text("".join(out), encoding="utf-8")
+        profile_config_yaml.update_model_surface(config_path, default=model_id)
     except OSError as exc:
         return False, f"write failed: {exc}"
     return True, ""
@@ -15146,54 +15290,7 @@ def _set_profile_model_provider(profile: str, provider: str) -> tuple[bool, str]
     if not provider:
         return False, "provider required"
     try:
-        raw = config_path.read_text(encoding="utf-8")
-    except OSError as exc:
-        return False, f"read failed: {exc}"
-
-    lines = raw.splitlines(keepends=True)
-    out: list[str] = []
-    in_model_block = False
-    wrote_provider = False
-    for line in lines:
-        stripped = line.lstrip()
-        if stripped.startswith("model:"):
-            if not in_model_block:
-                in_model_block = True
-                rest = stripped.split(":", 1)[1].strip().strip("'\"")
-                if rest:
-                    out.append("model:\n")
-                    out.append(f"  default: {rest}\n")
-                else:
-                    out.append("model:\n")
-            continue
-        if in_model_block and stripped and not line.startswith((" ", "\t", "#")):
-            if not wrote_provider:
-                out.append(f"  provider: {provider}\n")
-                wrote_provider = True
-            in_model_block = False
-        if in_model_block and stripped.startswith("provider:"):
-            indent = line[: len(line) - len(stripped)]
-            out.append(f"{indent}provider: {provider}\n")
-            wrote_provider = True
-            continue
-        out.append(line)
-
-    if not wrote_provider:
-        if not raw.endswith("\n") and out:
-            out.append("\n")
-        inserted = False
-        rebuilt: list[str] = []
-        for line in out:
-            rebuilt.append(line)
-            if not inserted and line.lstrip().startswith("model:"):
-                rebuilt.append(f"  provider: {provider}\n")
-                inserted = True
-        if not inserted:
-            rebuilt.insert(0, f"model:\n  provider: {provider}\n")
-        out = rebuilt
-
-    try:
-        config_path.write_text("".join(out), encoding="utf-8")
+        profile_config_yaml.update_model_surface(config_path, provider=provider)
     except OSError as exc:
         return False, f"write failed: {exc}"
     return True, ""
@@ -15284,6 +15381,15 @@ def _parse_model_block_from_disk(profile: str) -> dict[str, Any]:
                 in_fallback = False
             continue
 
+        if in_fallback and indent == fallback_indent + 2 and ":" in content and not content.startswith("- "):
+            # ponytail: wizard once wrote flat `model:` keys (no list) — tolerate one entry per line
+            k, _, v = content.partition(":")
+            key = k.strip()
+            val = v.strip().strip('"').strip("'")
+            if key == "model" and val:
+                out["fallback_chain"].append({"model": val})
+            continue
+
         if in_fallback and indent == fallback_indent + 2 and content.startswith("- "):
             # Start of a new fallback entry. First key may be inline.
             inline = content[2:].strip()
@@ -15320,14 +15426,17 @@ def _read_model_block(profile: str) -> dict[str, Any]:
     block = _parse_model_block_from_disk(prof)
     if not _is_runtime_profile_slug(prof):
         return block
+    # ponytail: runtime with model+provider on disk — skip template read on bind/chat hot path.
+    if str(block.get("default") or "").strip() and str(block.get("provider") or "").strip():
+        return block
     template = resolve_validated_profile(_runtime_template_slug(prof))
     tblock = _parse_model_block_from_disk(template)
-    if str(tblock.get("default") or "").strip():
+    if not str(block.get("default") or "").strip() and str(tblock.get("default") or "").strip():
         block["default"] = tblock["default"]
-    if tblock.get("fallback_chain"):
+    if not block.get("fallback_chain") and tblock.get("fallback_chain"):
         block["fallback_chain"] = list(tblock["fallback_chain"])
     tpl_provider = str(tblock.get("provider") or "").strip()
-    if tpl_provider:
+    if not str(block.get("provider") or "").strip() and tpl_provider:
         block["provider"] = tpl_provider
     return block
 
@@ -15340,114 +15449,45 @@ def _sync_runtime_model_from_template(runtime: str, template: str) -> None:
         return
     tblock = _parse_model_block_from_disk(template_slug)
     default = str(tblock.get("default") or "").strip()
-    if default:
-        _set_profile_model(runtime_slug, default)
+    if not default:
+        return
+    connected: set[str] = set()
+    billing = _billing_provider_id_from_hermes_config(str(tblock.get("provider") or ""))
+    if not billing:
+        billing = _resolve_billing_provider_for_model(default, connected) or ""
+    _, bare = _model_id_vendor_and_bare(default)
+    model_id = bare or default
+    if billing:
+        _apply_model_for_billing_provider(runtime_slug, billing, model_id)
+        return
+    _set_profile_model(runtime_slug, model_id)
     chain = [e for e in (tblock.get("fallback_chain") or []) if isinstance(e, dict)]
     if chain:
         _write_fallback_chain(runtime_slug, chain)
-    billing = _billing_provider_id_from_hermes_config(str(tblock.get("provider") or ""))
-    if billing and default:
-        _apply_model_for_billing_provider(runtime_slug, billing, default)
 
 
 def _write_fallback_chain(profile: str, chain: list[dict[str, str]]) -> tuple[bool, str]:
-    """Rewrite the `fallback_providers` block in config.yaml to match the
-    supplied chain. Preserves all other keys, comments, and ordering.
-    Strips ANY existing `fallback_providers:` blocks first — duplicates
-    can occur when a profile was migrated multiple times or when the
-    block was hand-edited — then inserts the new block at the natural
-    position (right after the `model:` section, before the next
-    top-level key).
-    """
+    """Rewrite fallback_providers via profile_config_yaml (WF-033)."""
+    _normalize_profile_config_yaml(profile)
     config_path = _profile_gateway_config_path(profile)
     if not config_path or not config_path.is_file():
         try:
             config_path = _ensure_gateway_config_file(profile)
         except ValueError as exc:
             return False, str(exc)
-    try:
-        raw = config_path.read_text(encoding="utf-8")
-    except OSError as exc:
-        return False, f"read failed: {exc}"
-
-    lines = raw.splitlines(keepends=True)
-
-    # Pass 1: drop every line that belongs to a `fallback_providers:`
-    # block (anywhere it appears in the file). We also remember whether
-    # a `model:` section existed so pass 2 can decide where to insert.
-    out: list[str] = []
-    in_fallback = False
-    saw_model = False
-    for line in lines:
-        stripped = line.rstrip()
-        if not stripped.strip():
-            out.append(line)
-            continue
-        indent = len(stripped) - len(stripped.lstrip())
-        content = stripped.lstrip()
-        if indent == 0 and content.startswith("model:"):
-            saw_model = True
-            in_fallback = False
-        if indent == 0 and content.startswith("fallback_providers:"):
-            in_fallback = True
-            continue
-        if in_fallback:
-            # A line is part of the block if it's indented more than 0
-            # (sub-keys), starts with `- ` (list item at the same
-            # indent as the key — also indent 0 here), or is otherwise
-            # not a fresh top-level key. Top-level (indent 0) non-fb
-            # keys end the block.
-            if indent > 0:
-                continue
-            if content.startswith("- "):
-                continue
-            if not content.startswith("fallback_providers"):
-                in_fallback = False
-        if indent == 0:
-            in_fallback = False
-        out.append(line)
-
-    # Pass 2: build the new block and find the right insertion point.
-    new_block: list[str] = ["fallback_providers:\n"]
+    normalized: list[dict[str, str]] = []
     for entry in chain:
+        if not isinstance(entry, dict):
+            continue
         provider = str(entry.get("provider", "")).strip()
         model = str(entry.get("model", "")).strip()
-        if not provider or not model:
-            continue
-        new_block.append(f"  - provider: {provider}\n")
-        new_block.append(f"    model: {model}\n")
-
-    if not saw_model:
-        # No model section at all — create a minimal one with the
-        # canonical primary plus the fallback chain.
-        if out and not out[-1].endswith("\n"):
-            out.append("\n")
-        out.append("model:\n")
-        out.append(f"  default: {HERMES_DEFAULT_PRIMARY}\n")
-        out.extend(new_block)
-    else:
-        # Insert just after the last line of the `model:` block, which
-        # is the first top-level key that follows it.
-        insertion = len(out)
-        in_model = False
-        for idx, line in enumerate(out):
-            stripped = line.rstrip()
-            if not stripped.strip():
-                continue
-            indent = len(stripped) - len(stripped.lstrip())
-            content = stripped.lstrip()
-            if indent == 0 and content.startswith("model:"):
-                in_model = True
-                continue
-            if indent == 0 and in_model:
-                insertion = idx
-                break
-        out[insertion:insertion] = new_block
-
+        if provider and model:
+            normalized.append({"provider": provider, "model": model})
     try:
-        config_path.write_text("".join(out), encoding="utf-8")
+        profile_config_yaml.update_model_surface(config_path, fallback_chain=normalized)
     except OSError as exc:
         return False, f"write failed: {exc}"
+    _normalize_profile_config_yaml(profile)
     return True, ""
 
 
@@ -15513,7 +15553,7 @@ def hermes_models(
     except ValueError as exc:
         return {"ok": False, "error": str(exc)}
     if primary_profile:
-        _bootstrap_profile_providers(primary_profile, user_id, workspace_id)
+        _ensure_profile_auth_pool(primary_profile, user_id, workspace_id)
     block = _read_model_block(primary_profile) if primary_profile else {
         "default": "", "provider": "", "base_url": "",
         "providers": {}, "fallback_chain": [],
@@ -15523,10 +15563,18 @@ def hermes_models(
         _suggestions_for_connected_llm_providers(connected_llm) if connected_llm else [],
         block,
     )
-    if user_id and "openrouter" in connected_llm:
+    primary_model = str(block.get("default") or "").strip()
+    billing = _billing_provider_id_from_hermes_config(active_provider)
+    if not billing and primary_model:
+        billing = _resolve_billing_provider_for_model(primary_model, connected_llm) or ""
+    _, bare_primary = _model_id_vendor_and_bare(primary_model)
+    if _oauth_llm_provider_spec(billing) and bare_primary:
+        primary_model = bare_primary
+    # ponytail: skip OpenRouter live catalog on Codex/other billing — blocks stdlib server up to 45s
+    if user_id and "openrouter" in connected_llm and billing in ("", "openrouter"):
         resolved = _resolve_credential(user_id, workspace_id, "openrouter", user_only=True)
         secret = _credential_secret(resolved or {}, user_id) if resolved else ""
-        live = openrouter_catalog.live_suggestions(secret, limit=30)
+        live = openrouter_catalog.live_suggestions(secret, limit=30, timeout=8)
         if live:
             seen = {str(r.get("model") or "") for r in suggestions}
             suggestions = [
@@ -15543,14 +15591,11 @@ def hermes_models(
         seen_models.add(mid)
         deduped.append(row)
     suggestions = deduped
-    primary_model = str(block.get("default") or "").strip()
-    billing = _billing_provider_id_from_hermes_config(active_provider)
-    if not billing and primary_model:
-        billing = _resolve_billing_provider_for_model(primary_model, connected_llm) or ""
-    if str(active_provider or "").lower() == "custom" and billing:
-        display_provider = billing
-    else:
-        display_provider = active_provider
+    if not billing and user_id and primary_profile:
+        billing = _llm_billing_provider(
+            primary_profile, user_id=user_id, workspace_id=workspace_id,
+        )
+    display_provider = billing
     return {
         "ok": True,
         "profile": primary_profile,
@@ -15598,6 +15643,7 @@ def hermes_model_set(
     workspace_id: str = "",
     *,
     selection_only: bool = False,
+    billing_provider: str = "",
 ) -> dict[str, Any]:
     """Set primary model and align Hermes provider routing to a connected billing provider."""
     user = str(user_id or "").strip()
@@ -15605,7 +15651,9 @@ def hermes_model_set(
         if not user:
             return {"ok": False, "error": "unauthorized"}
         connected = _user_llm_providers_for_picker(user)
-        billing = _resolve_billing_provider_for_model(model_id, connected)
+        billing = str(billing_provider or "").strip().lower()
+        if not billing:
+            billing = _resolve_billing_provider_for_model(model_id, connected)
         if not billing and not _user_llm_has_provider(user, workspace_id):
             return {"ok": False, "error": "connect an LLM provider first"}
         _write_user_llm_prefs(user, primary=model_id)
@@ -15625,28 +15673,46 @@ def hermes_model_set(
     user = str(user_id or "").strip()
     ws = str(workspace_id or "").strip()
     connected = _user_llm_providers_for_picker(user) if user else set()
-    billing = _resolve_billing_provider_for_model(model_id, connected)
+    billing = str(billing_provider or "").strip().lower()
+    if not billing:
+        prefer = _llm_billing_provider(target, user_id=user, workspace_id=ws) if target else ""
+        billing = _resolve_billing_provider_for_model(model_id, connected, prefer=prefer)
     if billing:
-        if not _apply_model_for_billing_provider(target, billing, model_id, user_id=user):
-            return {"ok": False, "error": "model apply failed"}
+        ok, err = _apply_model_persisted(
+            target, billing, model_id, user, restart_gateway=False,
+        )
+        if not ok:
+            return {"ok": False, "error": err}
     else:
-        ok, err = _set_profile_model(target, model_id)
+        ok, err = _apply_model_persisted(
+            target, "", model_id, user, restart_gateway=False,
+        )
         if not ok:
             return {"ok": False, "error": err}
     tpl = safe_profile_slug(target)
-    if user and not _is_runtime_profile_slug(tpl):
+    ok, err = _mirror_template_model_to_runtime(user, tpl, billing, model_id)
+    if not ok:
+        return {"ok": False, "error": err}
+    reload_prof = ""
+    if _is_runtime_profile_slug(target):
+        reload_prof = target
+    elif user:
         runtime = _runtime_profile_slug(user, tpl)
         if _runtime_profile_on_disk(runtime):
-            _sync_runtime_model_from_template(runtime, tpl)
+            reload_prof = runtime
+    if reload_prof:
+        _schedule_gateway_reload(reload_prof)
     block = _read_model_block(target)
+    resolved_billing = billing or _billing_provider_id_from_hermes_config(
+        str(block.get("provider") or "")
+    ) or _llm_billing_provider(target, user_id=user, workspace_id=ws)
+    persisted = _persisted_model_id(model_id, billing or resolved_billing)
     return {
         "ok": True,
         "profile": target,
-        "model": model_id,
-        "provider": str(block.get("provider") or ""),
-        "billing_provider": billing or _billing_provider_id_from_hermes_config(
-            str(block.get("provider") or "")
-        ),
+        "model": persisted,
+        "provider": resolved_billing,
+        "billing_provider": resolved_billing,
     }
 
 
@@ -15690,7 +15756,10 @@ def hermes_fallback_chain_set(
     if user and not _is_runtime_profile_slug(tpl):
         runtime = _runtime_profile_slug(user, tpl)
         if _runtime_profile_on_disk(runtime):
-            _sync_runtime_model_from_template(runtime, tpl)
+            ok, err = _write_fallback_chain(runtime, normalized)
+            if not ok:
+                return {"ok": False, "error": err or "runtime fallback apply failed"}
+            _schedule_gateway_reload(runtime)
     return {"ok": True, "profile": target, "fallback_chain": normalized}
 
 
@@ -16386,53 +16455,913 @@ class Handler(BaseHTTPRequestHandler):
             resolve_secret=_resolve_secret_for_lease,
         )
 
-    def do_GET(self) -> None:  # noqa: N802
-        parsed = urllib.parse.urlparse(self.path)
-        path = parsed.path
-        qs = urllib.parse.parse_qs(parsed.query)
+    # WF-037 data-read GET handlers (registered in route_registry.ROUTES)
+    def _route_get_meta(self, qs: dict[str, list[str]]) -> None:
+        self._json(200, workframe_meta())
 
-        if self._handle_internal_llm_proxy("GET", path):
+    def _route_get_health(self, qs: dict[str, list[str]]) -> None:
+        vault_stat = credential_vault.vault_status()
+        self._json(
+            200,
+            {
+                "ok": True,
+                "version": VERSION,
+                "mode": "dev_unsafe" if DEV_LOCAL_UNSAFE else "secure",
+                "secure_mode": SECURE_MODE,
+                "deployment_mode": DEPLOYMENT_MODE,
+                "admin_updates_enabled": os.environ.get("WORKFRAME_ENABLE_ADMIN_UPDATES") == "1",
+                "docker_sock_on_api": Path("/var/run/docker.sock").exists(),
+                "proxy_token_configured": internal_proxy_auth.proxy_token_configured(),
+                "vault_sealed": vault_stat.get("sealed"),
+                "vault_envelope": not vault_stat.get("sealed"),
+                "install_window_open": _install_window_open(),
+                "workframe_e2e": os.environ.get("WORKFRAME_E2E") == "1",
+                "dev_local_unsafe": DEV_LOCAL_UNSAFE,
+            },
+        )
+
+    def _route_get_setup_status(self, qs: dict[str, list[str]]) -> None:
+        try:
+            db = _workframe_db()
+            ws = db.execute("SELECT id FROM workspaces WHERE slug='default' AND deleted_at IS NULL").fetchone()
+            if not ws:
+                db.close()
+                self._json(200, {"setup_complete": False})
+                return
+            agents = db.execute(
+                "SELECT COUNT(*) AS c FROM agent_profiles WHERE workspace_id = ? AND deleted_at IS NULL",
+                (ws["id"],),
+            ).fetchone()
+            db.close()
+            self._json(200, {"setup_complete": bool(agents and agents["c"] > 0)})
+        except Exception:
+            self._json(200, {"setup_complete": False})
+
+    def _route_get_install_status(self, qs: dict[str, list[str]]) -> None:
+        if install_api.install_window_open(str(_workframe_db_path())):
+            try:
+                _ensure_native_hermes_profile()
+            except Exception:
+                pass
+        payload = install_api.install_status_payload(
+            DEPLOYMENT_MODE,
+            SECURE_MODE,
+            DEV_LOCAL_UNSAFE,
+            str(_workframe_db_path()),
+        )
+        self._json(200, payload)
+
+    def _route_get_public_site_meta(self, qs: dict[str, list[str]]) -> None:
+        self._json(200, _public_site_meta_payload())
+
+    def _route_get_public_link_preview(self, qs: dict[str, list[str]]) -> None:
+        meta = _public_site_meta_payload()
+        html = site_meta.link_preview_html(meta).encode("utf-8")
+        self._send(200, html, "text/html; charset=utf-8")
+
+    def _route_get_public_manifest(self, qs: dict[str, list[str]]) -> None:
+        meta = _public_site_meta_payload()
+        body = json.dumps(site_meta.manifest_payload(meta), indent=2).encode("utf-8")
+        self._send(200, body, "application/manifest+json; charset=utf-8")
+
+    def _route_get_me_cohort(self, qs: dict[str, list[str]]) -> None:
+        user_id = str(getattr(self, "auth_user", "") or "")
+        if not user_id:
+            self._json(401, {"ok": False, "error": "no_session"})
             return
-        if self._handle_internal_action_proxy("GET", path):
+        workspace_id = str(qs.get("workspace_id", [""])[0] or "").strip()
+        if not workspace_id:
+            self._json(400, {"ok": False, "error": "workspace_id_required"})
             return
+        ws_id = _resolve_wid(workspace_id) or workspace_id
+        if not _user_is_workspace_member(user_id, ws_id):
+            self._json(403, {"ok": False, "error": "forbidden"})
+            return
+        cohort = ensure_user_agent_cohort(user_id, ws_id)
+        self._json(
+            200,
+            {
+                "ok": True,
+                "workspace_id": ws_id,
+                "user_id": user_id,
+                "cohort": cohort,
+            },
+        )
 
-        # Auth middleware — returns 401 if session required and missing/invalid.
-        # In DEV_LOCAL_UNSAFE mode this is a no-op.
-        if not _auth_check(self):
-            return self._json(401, {"ok": False, "error": "no_session"})
+    def _route_get_user_credentials(self, qs: dict[str, list[str]]) -> None:
+        user_id = str(getattr(self, "auth_user", "") or "")
+        if not user_id:
+            if DEV_LOCAL_UNSAFE:
+                user_id = "dev"
+            else:
+                self._json(401, {"ok": False, "error": "no_authenticated_user"})
+                return
+        try:
+            conn = sqlite3.connect(str(AUTH_DB_PATH.parent / "workframe.db"), timeout=3.0)
+            conn.row_factory = sqlite3.Row
+            creds = conn.execute(
+                "SELECT id, workspace_id, user_id, agent_profile_id, provider, credential_type, label, is_active, created_at, updated_at FROM credential_bindings WHERE user_id = ? AND deleted_at IS NULL ORDER BY created_at DESC",
+                (user_id,),
+            ).fetchall()
+            conn.close()
+        except Exception:
+            creds = []
+        self._json(200, {"ok": True, "credentials": [dict(c) for c in creds]})
 
-        if SECURE_MODE:
-            if not _secure_host_origin_ok(self.command, path, self.headers):
-                if not _validate_host(self.headers):
-                    return self._json(403, {"error": "invalid host"})
-                return self._json(403, {"error": "invalid origin"})
+    def _route_get_agents(self, qs: dict[str, list[str]]) -> None:
+        self._json(200, workframe_agents())
 
-        try:
-            # Serve static files and UI
-            if path in ("", "/") or not path.startswith("/api/") and not path.startswith("/assets/") and not path.startswith("/static/"):
-                return self._file_public("index.html")
-            if path.startswith("/assets/"):
-                return self._file_public(path.lstrip("/"))
-            if path == "/api/health":
-                vault_stat = credential_vault.vault_status()
-                return self._json(
-                    200,
-                    {
-                        "ok": True,
-                        "version": VERSION,
-                        "mode": "dev_unsafe" if DEV_LOCAL_UNSAFE else "secure",
-                        "secure_mode": SECURE_MODE,
-                        "deployment_mode": DEPLOYMENT_MODE,
-                        "admin_updates_enabled": os.environ.get("WORKFRAME_ENABLE_ADMIN_UPDATES") == "1",
-                        "docker_sock_on_api": Path("/var/run/docker.sock").exists(),
-                        "proxy_token_configured": internal_proxy_auth.proxy_token_configured(),
-                        "vault_sealed": vault_stat.get("sealed"),
-                        "vault_envelope": not vault_stat.get("sealed"),
-                        "install_window_open": _install_window_open(),
-                        "workframe_e2e": os.environ.get("WORKFRAME_E2E") == "1",
-                        "dev_local_unsafe": DEV_LOCAL_UNSAFE,
-                    },
+    def _route_get_snapshot(self, qs: dict[str, list[str]]) -> None:
+        self._json(200, build_snapshot())
+
+    def _route_get_activity_detail(self, qs: dict[str, list[str]]) -> None:
+        profile = qs.get("profile", [""])[0].strip()
+        tool_call_id = qs.get("tool_call_id", [""])[0].strip()
+        session_id = qs.get("session_id", [""])[0].strip()
+        message_id = qs.get("message_id", [""])[0].strip()
+        self._json(200, activity_detail(profile, tool_call_id, session_id, message_id))
+
+    def _route_get_board(self, qs: dict[str, list[str]]) -> None:
+        self._json(200, board_list())
+
+    def _route_get_content(self, qs: dict[str, list[str]]) -> None:
+        self._json(200, content_list())
+
+    def _route_get_content_get(self, qs: dict[str, list[str]]) -> None:
+        rel = qs.get("path", [""])[0]
+        reason = _workspace_protected_reason(rel)
+        if reason:
+            self._json(403, {"ok": False, "error": "protected_file", "reason": reason})
+            return
+        fp = _safe_content_path(rel)
+        if not fp or not fp.is_file():
+            self._json(404, {"error": "not found"})
+            return
+        text = fp.read_text(encoding="utf-8", errors="replace")
+        self._json(200, {"path": rel, "content": text, "text": text})
+
+    def _route_get_files_tree(self, qs: dict[str, list[str]]) -> None:
+        self._json(200, {"root": files_tree()})
+
+    def _route_get_files_list(self, qs: dict[str, list[str]]) -> None:
+        rel = qs.get("path", [""])[0]
+        reason = _workspace_protected_reason(rel)
+        if reason:
+            self._json(403, {"ok": False, "error": "protected_file", "reason": reason})
+            return
+        self._json(200, files_list(rel))
+
+    def _route_get_files_state(self, qs: dict[str, list[str]]) -> None:
+        self._json(200, workspace_state())
+
+    def _route_get_files_read(self, qs: dict[str, list[str]]) -> None:
+        rel = qs.get("path", [""])[0]
+        reason = _workspace_protected_reason(rel)
+        if reason:
+            self._json(403, {"ok": False, "error": "protected_file", "reason": reason})
+            return
+        self._json(200, file_read(rel))
+
+    def _route_get_files_raw(self, qs: dict[str, list[str]]) -> None:
+        rel = qs.get("path", [""])[0]
+        reason = _workspace_protected_reason(rel)
+        if reason:
+            self._json(403, {"ok": False, "error": "protected_file", "reason": reason})
+            return
+        try:
+            data, mime = file_raw(rel)
+        except ValueError:
+            self._json(404, {"error": "not found"})
+            return
+        self._send(200, data, mime)
+
+    def _route_get_routes(self, qs: dict[str, list[str]]) -> None:
+        self._json(200, load_routes())
+
+    def _route_get_chat_messages(self, qs: dict[str, list[str]]) -> None:
+        profile = resolve_hermes_profile(qs.get("profile", [""])[0] or _primary_profile())
+        session = qs.get("session", [""])[0]
+        source_id = qs.get("source", ["ui"])[0]
+        self._json(200, chat_messages(profile, session, source_id))
+
+    def _route_get_chat_session(self, qs: dict[str, list[str]]) -> None:
+        profile = resolve_hermes_profile(qs.get("profile", [""])[0] or _primary_profile())
+        session = qs.get("session", [""])[0]
+        source_id = qs.get("source", ["ui"])[0]
+        self._json(200, chat_session(profile, session, source_id))
+
+    def _route_get_chat_resolve(self, qs: dict[str, list[str]]) -> None:
+        profile = resolve_validated_profile(qs.get("profile", [""])[0] or _primary_profile())
+        source_id = qs.get("source", ["ui"])[0]
+        client_id = qs.get("client", ["default"])[0]
+        self._json(
+            200,
+            chat_resolve({"profile": profile, "source_id": source_id, "client_id": client_id}),
+        )
+
+    def _route_get_hermes_skills(self, qs: dict[str, list[str]]) -> None:
+        self._json(200, {"skills": hermes_skills()})
+
+    def _route_get_hermes_commands(self, qs: dict[str, list[str]]) -> None:
+        self._json(200, hermes_commands_catalog())
+
+    def _route_get_hermes_usage(self, qs: dict[str, list[str]]) -> None:
+        self._json(200, hermes_usage())
+
+    def _route_get_hermes_profile(self, qs: dict[str, list[str]]) -> None:
+        self._json(200, hermes_profile())
+
+    def _route_get_me(self, qs: dict[str, list[str]]) -> None:
+        user_id = str(getattr(self, "auth_user", "") or "")
+        if not user_id:
+            self._json(401, {"ok": False, "error": "no_session"})
+            return
+        payload = _session_profile_payload(user_id)
+        if not payload:
+            self._json(404, {"ok": False, "error": "user_not_found"})
+            return
+        self._json(200, payload)
+
+    def _route_get_me_onboarding(self, qs: dict[str, list[str]]) -> None:
+        user_id = str(getattr(self, "auth_user", "") or "")
+        if not user_id:
+            self._json(401, {"ok": False, "error": "no_session"})
+            return
+        self._json(200, _onboarding_payload(user_id))
+
+    def _route_get_me_credentials(self, qs: dict[str, list[str]]) -> None:
+        user_id = str(getattr(self, "auth_user", "") or "")
+        if not user_id:
+            self._json(401, {"ok": False, "error": "no_session"})
+            return
+        try:
+            conn = sqlite3.connect(str(_workframe_db_path()), timeout=3.0)
+            conn.row_factory = sqlite3.Row
+            rows = conn.execute(
+                """SELECT id, workspace_id, user_id, agent_profile_id, provider, credential_type,
+                       credential_ref, label, is_active, created_at, updated_at
+                   FROM credential_bindings
+                   WHERE user_id = ? AND deleted_at IS NULL
+                   ORDER BY updated_at DESC, created_at DESC""",
+                (user_id,),
+            ).fetchall()
+            conn.close()
+        except sqlite3.Error as exc:
+            self._json(500, {"ok": False, "error": f"db_error: {exc}"})
+            return
+        self._json(200, {"ok": True, "credentials": [dict(row) for row in rows]})
+
+    def _route_get_me_providers(self, qs: dict[str, list[str]]) -> None:
+        user_id = str(getattr(self, "auth_user", "") or "")
+        if not user_id:
+            self._json(401, {"ok": False, "error": "no_session"})
+            return
+        workspace_id = qs.get("workspace_id", [""])[0]
+        self._json(200, list_user_providers(user_id, workspace_id))
+
+    def _route_get_hermes_models(self, qs: dict[str, list[str]]) -> None:
+        profile = qs.get("profile", [""])[0]
+        user_id = str(getattr(self, "auth_user", "") or "")
+        workspace_id = qs.get("workspace_id", [""])[0]
+        selection_only = qs.get("selection_only", ["0"])[0] in {"1", "true", "yes"}
+        payload = hermes_models(profile, user_id, workspace_id, selection_only=selection_only)
+        status = 200 if payload.get("ok", True) else 400
+        self._json(status, payload)
+
+    def _route_get_hermes_debug(self, qs: dict[str, list[str]]) -> None:
+        self._json(200, hermes_debug())
+
+    def _route_get_hermes_insights(self, qs: dict[str, list[str]]) -> None:
+        self._json(200, hermes_insights())
+
+    def _route_get_hermes_gquota(self, qs: dict[str, list[str]]) -> None:
+        self._json(200, hermes_gquota())
+
+    # WF-037 auth-flow + hermes/chat + me credentials POST handlers
+    def _route_post_auth_google_start(self, body: dict) -> None:
+        invite_email = str(body.get("email") or "").strip().lower()
+        invite_token = str(body.get("invite_token") or "")
+        if invite_email:
+            allowed, deny_meta = _email_allowed_to_authenticate(invite_email)
+            if not allowed and not _invite_token_allows_email(invite_token, invite_email):
+                self._log_audit(
+                    "login_denied_private",
+                    "user",
+                    invite_email,
+                    str(deny_meta.get("error") or ""),
                 )
+                self._json(403, {"ok": False, **deny_meta})
+                return
+        try:
+            payload = google_auth.start_google_auth(invite_email, invite_token)
+            self._json(200, payload)
+        except ValueError as exc:
+            self._json(400, {"ok": False, "error": str(exc)})
+
+    def _route_post_auth_local_bootstrap(self, body: dict) -> None:
+        if DEPLOYMENT_MODE != "single_user_local" or not _install_window_open():
+            self._json(403, {"ok": False, "error": "local_bootstrap_unavailable"})
+            return
+        display = str(body.get("display_name") or "Owner")
+        email = "owner@local.workframe"
+        try:
+            result = _zk.create_session_for_email(email)
+        except Exception as exc:
+            self._json(500, {"ok": False, "error": str(exc)})
+            return
+        user_id = str(result["user_id"])
+        self.auth_user = user_id
+        self._ensure_user(user_id, display, email)
+        self._first_owner_bootstrap(user_id, display, email)
+        use_secure = _session_cookie_secure()
+        cookie_val = _zk.session_cookie_value(result["session_id"], secure=use_secure)
+        me_payload = _session_profile_payload(user_id)
+        self._json(
+            200,
+            {
+                "ok": True,
+                "user_id": user_id,
+                "session_id": result["session_id"],
+                "refresh_token": result["refresh_token"],
+                **(me_payload or {}),
+            },
+            extra_headers=[("Set-Cookie", cookie_val)],
+        )
+
+    def _route_post_auth_bootstrap(self, body: dict) -> None:
+        if not SECURE_MODE:
+            self._json(501, {"ok": False, "error": "bootstrap_requires_secure_mode"})
+            return
+        data = body if isinstance(body, dict) else {}
+        user_id = str(data.get("user_id", "") or secrets.token_hex(8))
+        user_email = str(data.get("email", ""))
+        user_display = str(data.get("display_name", "") or "Owner")
+        result = self._first_owner_bootstrap(user_id, user_display, user_email)
+        self._log_audit("user_created", "user", user_id, f"first-owner bootstrap: {user_display}")
+        self._json(200, result)
+
+    def _route_post_setup(self, body: dict) -> None:
+        data = body if isinstance(body, dict) else {}
+        agent_name = str(data.get("agent_name", "")).strip()
+        workframe_name = str(data.get("workframe_name", "")).strip()
+        if not agent_name:
+            self._json(400, {"ok": False, "error": "agent_name required"})
+            return
+        try:
+            db = _workframe_db()
+            ws = db.execute("SELECT * FROM workspaces WHERE slug='default' AND deleted_at IS NULL").fetchone()
+            if not ws:
+                ws_id = str(uuid.uuid4())
+                now = str(int(time.time()))
+                workspace_display_name = workframe_name or "Default Workspace"
+                ws_settings = stack_config.github_oauth_for_workspace_settings({})
+                settings_json = json.dumps(ws_settings, sort_keys=True) if ws_settings else "{}"
+                db.execute(
+                    "INSERT INTO workspaces (id, slug, display_name, description, owner_id, status, created_at, updated_at, settings_json) VALUES (?, 'default', ?, '', '', 'active', ?, ?, ?)",
+                    (ws_id, workspace_display_name, now, now, settings_json),
+                )
+                ws = db.execute("SELECT * FROM workspaces WHERE id = ?", (ws_id,)).fetchone()
+            elif workframe_name and str(ws["display_name"] or "").strip() != workframe_name:
+                now = str(int(time.time()))
+                db.execute(
+                    "UPDATE workspaces SET display_name = ?, updated_at = ? WHERE id = ?",
+                    (workframe_name, now, ws["id"]),
+                )
+                ws = db.execute("SELECT * FROM workspaces WHERE id = ?", (ws["id"],)).fetchone()
+            ws_id = ws["id"]
+            existing_agents = db.execute("SELECT COUNT(*) AS c FROM agent_profiles WHERE workspace_id = ? AND deleted_at IS NULL", (ws_id,)).fetchone()
+            if existing_agents and existing_agents["c"] > 0:
+                if agent_name:
+                    now = str(int(time.time()))
+                    db.execute(
+                        """
+                        UPDATE agent_profiles
+                        SET display_name = ?, updated_at = ?
+                        WHERE workspace_id = ? AND is_native = 1 AND deleted_at IS NULL
+                        """,
+                        (agent_name, now, ws_id),
+                    )
+                    db.commit()
+                db.close()
+                self._json(200, {"ok": True, "already_initialized": True, "workspace_id": ws_id})
+                return
+            import re as _re
+            agent_slug = _re.sub(r"[^a-z0-9-]", "", agent_name.lower().replace(" ", "-"))[:40]
+            agent_id = str(uuid.uuid4())
+            now = str(int(time.time()))
+            db.execute(
+                "INSERT INTO agent_profiles (id, workspace_id, slug, display_name, tagline, role, is_native, status, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, 1, 'active', ?, ?)",
+                (agent_id, ws_id, agent_slug, agent_name, str(data.get("agent_personality", "")), "native", now, now),
+            )
+            room_id = str(uuid.uuid4())
+            db.execute(
+                "INSERT INTO rooms (id, workspace_id, name, slug, topic, room_type, status, created_at, updated_at) VALUES (?, ?, ?, ?, ?, 'channel', 'active', ?, ?)",
+                (room_id, ws_id, "General", "general", "General discussion", now, now),
+            )
+            db.commit()
+            db.close()
+            hermes = _bootstrap_after_setup(str(data.get("agent_personality", "")))
+            self._json(
+                200,
+                {
+                    "ok": True,
+                    "workspace_id": ws_id,
+                    "agent_id": agent_id,
+                    "room_id": room_id,
+                    "hermes": hermes,
+                },
+            )
+        except Exception as exc:
+            self._json(500, {"ok": False, "error": str(exc)})
+
+    def _route_post_auth_start(self, body: dict) -> None:
+        email = str(body.get("email", "")).strip().lower()
+        if not email or "@" not in email:
+            self._json(400, {"ok": False, "error": "email required"})
+            return
+        client_ip = str(self.client_address[0] if self.client_address else "")
+        import auth_rate_limit
+
+        if not auth_rate_limit.allow_auth_request("start", client_ip, email):
+            self._json(429, {"ok": False, "error": "too_many_requests"})
+            return
+        allowed, deny_meta = _email_allowed_to_authenticate(email)
+        if not allowed:
+            self._log_audit("login_denied_private", "user", email, str(deny_meta.get("error") or ""))
+            self._json(403, {"ok": False, **deny_meta})
+            return
+        try:
+            base = APP_BASE_URL.strip().lower()
+            loopback = base.startswith("http://127.0.0.1") or base.startswith("http://localhost")
+            expose_otp = (
+                os.environ.get("WORKFRAME_E2E") == "1"
+                and _install_window_open()
+                and loopback
+            )
+            result = _zk.start_email_verification(
+                email,
+                dev_local_unsafe=DEV_LOCAL_UNSAFE,
+                expose_otp=expose_otp,
+            )
+        except Exception as exc:
+            self._json(500, {"ok": False, "error": str(exc)})
+            return
+        if not DEV_LOCAL_UNSAFE and not expose_otp:
+            result.pop("otp_code", None)
+            result.pop("_dev_warning", None)
+        result.pop("_e2e_warning", None)
+        self._log_audit("otp_requested", "user", email, f"challenge={result.get('challenge_id','')}")
+        self._json(200, {"ok": True, "status": "verification_sent", **result})
+
+    def _route_post_auth_verify(self, body: dict) -> None:
+        email = str(body.get("email", "")).strip().lower()
+        code = str(body.get("code", "")).strip()
+        if not email or not code:
+            self._json(400, {"ok": False, "error": "email and code required"})
+            return
+        client_ip = str(self.client_address[0] if self.client_address else "")
+        import auth_rate_limit
+
+        if not auth_rate_limit.allow_auth_request("verify", client_ip, email):
+            self._json(429, {"ok": False, "error": "too_many_requests"})
+            return
+        allowed, deny_meta = _email_allowed_to_authenticate(email)
+        if not allowed:
+            self._log_audit("login_denied_private", "user", email, str(deny_meta.get("error") or ""))
+            self._json(403, {"ok": False, **deny_meta})
+            return
+        try:
+            result = _zk.verify_email_code(email, code)
+        except ValueError as exc:
+            self._log_audit("login_failed", "user", email, f"verify failed: {exc}")
+            self._json(401, {"ok": False, "error": str(exc)})
+            return
+        except Exception as exc:
+            self._json(500, {"ok": False, "error": str(exc)})
+            return
+        use_secure = _session_cookie_secure()
+        cookie_val = _zk.session_cookie_value(result["session_id"], secure=use_secure)
+        self.auth_user = result["user_id"]
+        self._ensure_user(result["user_id"], email, email)
+        self._log_audit("login", "session", result["session_id"],
+                        f"user={result['user_id']} new={result['is_new_user']}")
+        me_payload = _session_profile_payload(result["user_id"])
+        self._json(
+            200,
+            {
+                "ok": True,
+                "user_id": result["user_id"],
+                "session_id": result["session_id"],
+                "refresh_token": result["refresh_token"],
+                "expires_at": result["expires_at"],
+                "is_new_user": result["is_new_user"],
+                **(me_payload or {}),
+            },
+            extra_headers=[("Set-Cookie", cookie_val)],
+        )
+
+    def _route_post_auth_logout(self, body: dict) -> None:
+        sid = _session_id_from_request(self)
+        user_id = str(getattr(self, "auth_user", "") or "")
+        if sid:
+            try:
+                _zk.logout_session(sid)
+            except Exception:
+                pass
+        use_secure = _session_cookie_secure()
+        cookie_val = _zk.clear_session_cookie(secure=use_secure)
+        self._log_audit("logout", "session", sid, f"user={user_id}")
+        self._json(200, {"ok": True}, extra_headers=[("Set-Cookie", cookie_val)])
+
+    def _route_post_auth_refresh(self, body: dict) -> None:
+        refresh_token = str(body.get("refresh_token", "")).strip()
+        if not refresh_token:
+            sid = _session_id_from_request(self)
+            if not sid:
+                self._json(400, {"ok": False, "error": "refresh_token required"})
+                return
+            validated = _zk.validate_session_token(sid)
+            if not validated:
+                self._json(401, {"ok": False, "error": "session_expired"})
+                return
+            use_secure = _session_cookie_secure()
+            cookie_val = _zk.session_cookie_value(validated["session_id"], secure=use_secure)
+            self._json(
+                200,
+                {
+                    "ok": True,
+                    "user_id": validated["user_id"],
+                    "session_id": validated["session_id"],
+                    "expires_at": validated["expires_at"],
+                },
+                extra_headers=[("Set-Cookie", cookie_val)],
+            )
+            return
+        try:
+            result = _zk.refresh_session(refresh_token)
+        except ValueError as exc:
+            self._json(401, {"ok": False, "error": str(exc)})
+            return
+        except Exception as exc:
+            self._json(500, {"ok": False, "error": str(exc)})
+            return
+        use_secure = _session_cookie_secure()
+        cookie_val = _zk.session_cookie_value(result["session_id"], secure=use_secure)
+        self._log_audit("session_refreshed", "session", result["session_id"],
+                        f"user={result['user_id']}")
+        self._json(
+            200,
+            {
+                "ok": True,
+                "user_id": result["user_id"],
+                "session_id": result["session_id"],
+                "refresh_token": result["refresh_token"],
+                "expires_at": result["expires_at"],
+            },
+            extra_headers=[("Set-Cookie", cookie_val)],
+        )
+
+    def _route_post_me_credentials(self, body: dict) -> None:
+        user_id = str(getattr(self, "auth_user", "") or "")
+        if not user_id:
+            self._json(401, {"ok": False, "error": "no_session"})
+            return
+        provider = str(body.get("provider", "")).strip()
+        credential_type = str(body.get("credential_type", "api_key")).strip() or "api_key"
+        secret = str(body.get("secret", "")).strip()
+        spec = _catalog_provider(provider)
+        if spec:
+            credential_type = str(spec.get("connect_mode") or credential_type)
+        env_var = str(body.get("env_var", "")).strip() or (
+            str(spec.get("env_var") or "") if spec else ""
+        ) or _default_credential_env_var(provider, credential_type)
+        label = str(body.get("label", "")).strip() or env_var
+        if not provider:
+            self._json(400, {"ok": False, "error": "provider required"})
+            return
+        if not secret:
+            self._json(400, {"ok": False, "error": "secret required"})
+            return
+        payload = _store_user_credential(user_id, provider, credential_type, secret, env_var, label)
+        cred_ref = str(payload["credential_ref"])
+        now = _utc_now()
+        try:
+            conn = sqlite3.connect(str(_workframe_db_path()), timeout=3.0)
+            conn.row_factory = sqlite3.Row
+            existing = conn.execute(
+                """SELECT id FROM credential_bindings
+                   WHERE user_id = ? AND provider = ? AND credential_type = ?
+                     AND credential_ref = ? AND deleted_at IS NULL
+                   ORDER BY updated_at DESC, created_at DESC LIMIT 1""",
+                (user_id, provider, credential_type, cred_ref),
+            ).fetchone()
+            if existing:
+                cred_id = str(existing["id"])
+                conn.execute(
+                    """UPDATE credential_bindings
+                       SET label = ?, is_active = 1, updated_at = ?, deleted_at = NULL
+                       WHERE id = ?""",
+                    (label, now, cred_id),
+                )
+            else:
+                cred_id = str(payload["credential_id"])
+                conn.execute(
+                    """INSERT INTO credential_bindings
+                       (id, workspace_id, user_id, agent_profile_id, provider, credential_type,
+                        credential_ref, label, is_active, created_by, created_at, updated_at)
+                       VALUES (?,?,?,?,?,?,?,?,?,?,?,?)""",
+                    (cred_id, None, user_id, None, provider, credential_type, cred_ref, label, 1, user_id, now, now),
+                )
+            conn.execute(
+                """UPDATE credential_bindings
+                   SET is_active = 0, deleted_at = ?, updated_at = ?
+                   WHERE user_id = ? AND provider = ? AND deleted_at IS NULL AND id != ?""",
+                (now, now, user_id, provider, cred_id),
+            )
+            conn.commit()
+            conn.close()
+        except sqlite3.Error as exc:
+            self._json(500, {"ok": False, "error": f"db_error: {exc}"})
+            return
+        self._log_audit("credential_stored", "credential_binding", cred_id, f"provider={provider}")
+        health: dict[str, Any] = {}
+        if provider == "openrouter":
+            secret_probe = _credential_secret(
+                {
+                    "credential_ref": cred_ref,
+                    "scope": "user",
+                    "user_id": user_id,
+                },
+                user_id,
+            )
+            if secret_probe:
+                health = openrouter_catalog.probe_account(secret_probe)
+        _bootstrap_model_after_llm_connect(user_id, str(body.get("workspace_id") or ""), provider)
+        self._json(200, {
+            "ok": True,
+            "credential_id": cred_id,
+            "provider": provider,
+            "credential_type": credential_type,
+            "label": label,
+            "is_active": 1,
+            "user_id": user_id,
+            "created_at": now,
+            "updated_at": now,
+            "health": health,
+            **payload,
+        })
+
+    def _route_post_me_telegram_link(self, body: dict) -> None:
+        user_id = str(getattr(self, "auth_user", "") or "")
+        if not user_id:
+            self._json(401, {"ok": False, "error": "no_session"})
+            return
+        result = platform_auth.verify_telegram_login(body if isinstance(body, dict) else {})
+        if not result.get("ok"):
+            self._json(400, {"ok": False, "error": result.get("error") or "telegram_link_failed"})
+            return
+        patch = result.get("platform_ids") if isinstance(result.get("platform_ids"), dict) else {}
+        if patch:
+            _merge_user_platform_ids(user_id, {str(k): str(v) for k, v in patch.items()})
+        self._json(200, {"ok": True, "provider": "telegram", "platform_ids": patch})
+
+    def _route_post_hermes_commands_exec(self, body: dict) -> None:
+        if not _check_auth(self):
+            self._json(401, {"error": "unauthorized"})
+            return
+        line = str(body.get("line", "")).strip()
+        if not line:
+            self._json(400, {"error": "line required"})
+            return
+        self._json(200, hermes_commands_exec(line))
+
+    def _route_post_hermes_gateway_exec(self, body: dict) -> None:
+        if not _check_auth(self):
+            self._json(401, {"error": "unauthorized"})
+            return
+        line = str(body.get("line", "")).strip()
+        profile = str(body.get("profile", "")).strip()
+        if not line:
+            self._json(400, {"error": "line required"})
+            return
+        user_id = str(getattr(self, "auth_user", "") or "")
+        workspace_id = str(body.get("workspace_id", "") or "")
+        self._json(
+            200,
+            hermes_gateway_exec(line, profile, user_id=user_id, workspace_id=workspace_id),
+        )
+
+    def _route_post_chat_stop(self, body: dict) -> None:
+        if not _check_auth(self):
+            self._json(401, {"error": "unauthorized"})
+            return
+        profile = resolve_validated_profile(str(body.get("profile") or _primary_profile()))
+        run_id = str(body.get("run_id") or "").strip()
+        if not run_id:
+            run_id = _latest_active_run_id(profile)
+        if not run_id:
+            self._json(400, {"error": "no active run to stop"})
+            return
+        self._json(200, profile_gateway_stop(profile, run_id))
+
+    def _route_post_chat_steer(self, body: dict) -> None:
+        if not _check_auth(self):
+            self._json(401, {"error": "unauthorized"})
+            return
+        profile = resolve_validated_profile(str(body.get("profile") or _primary_profile()))
+        run_id = str(body.get("run_id") or "").strip()
+        text = str(body.get("text") or "").strip()
+        if not text:
+            self._json(400, {"error": "text required"})
+            return
+        if not run_id:
+            run_id = _latest_active_run_id(profile)
+        self._json(200, profile_gateway_steer(profile, run_id or "", text))
+
+    def _route_post_hermes_model(self, body: dict) -> None:
+        if not _check_auth(self):
+            self._json(401, {"error": "unauthorized"})
+            return
+        model_id = str(body.get("model", "")).strip()
+        profile = str(body.get("profile", "")).strip()
+        user_id = str(getattr(self, "auth_user", "") or "")
+        workspace_id = str(body.get("workspace_id", "")).strip()
+        selection_only = bool(body.get("selection_only"))
+        if not model_id:
+            self._json(400, {"error": "model required"})
+            return
+        billing_provider = str(body.get("billing_provider", "")).strip()
+        self._json(
+            200,
+            hermes_model_set(
+                profile,
+                model_id,
+                user_id,
+                workspace_id,
+                selection_only=selection_only,
+                billing_provider=billing_provider,
+            ),
+        )
+
+    def _route_post_hermes_model_apply_default(self, body: dict) -> None:
+        if not _check_auth(self):
+            self._json(401, {"error": "unauthorized"})
+            return
+        if not _role_allows(self, OWNER_ADMIN_ROLES):
+            self._json(403, {"ok": False, "error": "forbidden", "required_role": "owner_or_admin"})
+            return
+        self._json(200, hermes_apply_default_model_config())
+
+    def _route_post_hermes_fallback_chain(self, body: dict) -> None:
+        if not _check_auth(self):
+            self._json(401, {"error": "unauthorized"})
+            return
+        profile = str(body.get("profile", "")).strip()
+        chain = body.get("chain", [])
+        selection_only = bool(body.get("selection_only"))
+        user_id = str(getattr(self, "auth_user", "") or "")
+        if not isinstance(chain, list):
+            self._json(400, {"error": "chain must be a list"})
+            return
+        if not selection_only and not _role_allows(self, OWNER_ADMIN_ROLES):
+            self._json(403, {"ok": False, "error": "forbidden", "required_role": "owner_or_admin"})
+            return
+        self._json(
+            200,
+            hermes_fallback_chain_set(
+                profile,
+                chain,
+                selection_only=selection_only,
+                user_id=user_id,
+            ),
+        )
+
+    def _route_post_board(self, body: dict) -> None:
+        if not _check_auth(self):
+            self._json(401, {"error": "unauthorized"})
+            return
+        self._json(201, board_create(body))
+
+    def _route_post_board_update(self, body: dict) -> None:
+        if not _check_auth(self):
+            self._json(401, {"error": "unauthorized"})
+            return
+        qs = getattr(self, "_post_qs", {})
+        task_id = qs.get("id", [""])[0]
+        if not task_id:
+            self._json(400, {"error": "id required"})
+            return
+        self._json(200, board_update(task_id, body))
+
+    def _route_post_board_delete(self, body: dict) -> None:
+        if not _check_auth(self):
+            self._json(401, {"error": "unauthorized"})
+            return
+        qs = getattr(self, "_post_qs", {})
+        task_id = qs.get("id", [""])[0]
+        if not task_id:
+            self._json(400, {"error": "id required"})
+            return
+        board_delete(task_id)
+        self._json(200, {"ok": True})
+
+    def _route_post_content_save(self, body: dict) -> None:
+        if not _check_auth(self):
+            self._json(401, {"error": "unauthorized"})
+            return
+        rel = str(body.get("path") or "").strip()
+        reason = _workspace_protected_reason(rel)
+        if reason:
+            self._json(403, {"ok": False, "error": "protected_file", "reason": reason})
+            return
+        content = str(body.get("content") or "")
+        fp = _safe_content_path(rel)
+        if not fp:
+            self._json(400, {"error": "invalid path"})
+            return
+        fp.parent.mkdir(parents=True, exist_ok=True)
+        fp.write_text(content, encoding="utf-8")
+        _bump_workspace_state(fp)
+        self._json(200, {"ok": True, "path": rel.replace("\\", "/")})
+
+    def _route_post_content_delete(self, body: dict) -> None:
+        if not _check_auth(self):
+            self._json(401, {"error": "unauthorized"})
+            return
+        qs = getattr(self, "_post_qs", {})
+        rel = qs.get("path", [""])[0] or str(body.get("path") or "")
+        reason = _workspace_protected_reason(rel)
+        if reason:
+            self._json(403, {"ok": False, "error": "protected_file", "reason": reason})
+            return
+        fp = _safe_content_path(rel)
+        if not fp or not fp.is_file():
+            self._json(404, {"error": "not found"})
+            return
+        fp.unlink()
+        _bump_workspace_state(fp.parent)
+        self._json(200, {"ok": True})
+
+    def _route_post_files_write(self, body: dict) -> None:
+        if not _check_auth(self):
+            self._json(401, {"error": "unauthorized"})
+            return
+        rel = str(body.get("path") or "").strip()
+        reason = _workspace_protected_reason(rel)
+        if reason:
+            self._json(403, {"ok": False, "error": "protected_file", "reason": reason})
+            return
+        content = str(body.get("content") or "")
+        self._json(200, file_write(rel, content))
+
+    def _route_post_files_upload(self, body: dict) -> None:
+        if not _check_auth(self):
+            self._json(401, {"error": "unauthorized"})
+            return
+        rel = str(body.get("path") or "").strip()
+        reason = _workspace_protected_reason(rel)
+        if reason:
+            self._json(403, {"ok": False, "error": "protected_file", "reason": reason})
+            return
+        content_b64 = str(body.get("content_base64") or body.get("content") or "")
+        self._json(200, file_upload_binary(rel, content_b64))
+
+    def _route_post_chat_dispatch(self, body: dict) -> None:
+        if not _check_auth(self):
+            self._json(401, {"error": "unauthorized"})
+            return
+        self._json(200, chat_dispatch(body))
+
+    def do_GET(self) -> None:  # noqa: N802
+        parsed = urllib.parse.urlparse(self.path)
+        path = parsed.path
+        qs = urllib.parse.parse_qs(parsed.query)
+
+        if self._handle_internal_llm_proxy("GET", path):
+            return
+        if self._handle_internal_action_proxy("GET", path):
+            return
+
+        # Auth middleware — returns 401 if session required and missing/invalid.
+        # In DEV_LOCAL_UNSAFE mode this is a no-op.
+        if not _auth_check(self):
+            return self._json(401, {"ok": False, "error": "no_session"})
+
+        if SECURE_MODE:
+            if not _secure_host_origin_ok(self.command, path, self.headers):
+                if not _validate_host(self.headers):
+                    return self._json(403, {"error": "invalid host"})
+                return self._json(403, {"error": "invalid origin"})
+
+        try:
+            if route_registry.dispatch_get(self, path, qs):
+                return
+
+            # Serve static files and UI
+            if path in ("", "/") or not path.startswith("/api/") and not path.startswith("/assets/") and not path.startswith("/static/"):
+                return self._file_public("index.html")
+            if path.startswith("/assets/"):
+                return self._file_public(path.lstrip("/"))
             if path == "/api/admin/vault/status":
                 if not _role_allows(self, OWNER_ADMIN_ROLES):
                     return self._json(403, {"ok": False, "error": "forbidden", "required_role": "owner_or_admin"})
@@ -16462,44 +17391,6 @@ class Handler(BaseHTTPRequestHandler):
                     self.end_headers()
                     return
                 return self._json(403, {"ok": False, "error": "dashboard_forbidden"})
-            if path == "/api/setup/status":
-                # Public endpoint: check if default workspace has agents (setup complete?)
-                try:
-                    db = _workframe_db()
-                    ws = db.execute("SELECT id FROM workspaces WHERE slug='default' AND deleted_at IS NULL").fetchone()
-                    if not ws:
-                        db.close()
-                        return self._json(200, {"setup_complete": False})
-                    agents = db.execute("SELECT COUNT(*) AS c FROM agent_profiles WHERE workspace_id = ? AND deleted_at IS NULL", (ws["id"],)).fetchone()
-                    db.close()
-                    return self._json(200, {"setup_complete": bool(agents and agents["c"] > 0)})
-                except Exception:
-                    return self._json(200, {"setup_complete": False})
-            if path == "/api/install/status":
-                if install_api.install_window_open(str(_workframe_db_path())):
-                    try:
-                        _ensure_native_hermes_profile()
-                    except Exception:
-                        pass
-                payload = install_api.install_status_payload(
-                    DEPLOYMENT_MODE,
-                    SECURE_MODE,
-                    DEV_LOCAL_UNSAFE,
-                    str(_workframe_db_path()),
-                )
-                return self._json(200, payload)
-            if path == "/api/public/site-meta":
-                return self._json(200, _public_site_meta_payload())
-            if path == "/api/public/link-preview":
-                meta = _public_site_meta_payload()
-                html = site_meta.link_preview_html(meta).encode("utf-8")
-                self._send(200, html, "text/html; charset=utf-8")
-                return
-            if path == "/api/public/manifest.webmanifest":
-                meta = _public_site_meta_payload()
-                body = json.dumps(site_meta.manifest_payload(meta), indent=2).encode("utf-8")
-                self._send(200, body, "application/manifest+json; charset=utf-8")
-                return
             branding_match = re.fullmatch(r"/api/public/branding/(og|favicon)", path)
             if branding_match:
                 asset = site_meta.branding_asset_bytes(branding_match.group(1))
@@ -16557,61 +17448,18 @@ class Handler(BaseHTTPRequestHandler):
                         redirect_to = (
                             f"{APP_BASE_URL.rstrip('/')}/?invite_token="
                             f"{urllib.parse.quote(invite_token)}&email={urllib.parse.quote(profile['email'])}"
-                        )
-                    self.send_response(302)
-                    self.send_header("Location", redirect_to)
-                    self.send_header("Set-Cookie", cookie_val)
-                    cors_origin = _cors_origin_for(self.headers)
-                    if cors_origin:
-                        self.send_header("Access-Control-Allow-Origin", cors_origin)
-                        self.send_header("Vary", "Origin")
-                    self.end_headers()
-                    return
-                except Exception as exc:
-                    return self._json(401, {"ok": False, "error": str(exc)})
-            if path == "/api/me":
-                # zk-auth compatible profile endpoint (GET)
-                user_id = str(getattr(self, "auth_user", "") or "")
-                if not user_id:
-                    return self._json(401, {"ok": False, "error": "no_session"})
-                payload = _session_profile_payload(user_id)
-                if not payload:
-                    return self._json(404, {"ok": False, "error": "user_not_found"})
-                return self._json(200, payload)
-
-            if path == "/api/me/onboarding":
-                user_id = str(getattr(self, "auth_user", "") or "")
-                if not user_id:
-                    return self._json(401, {"ok": False, "error": "no_session"})
-                return self._json(200, _onboarding_payload(user_id))
-
-            if path == "/api/me/credentials":
-                user_id = str(getattr(self, "auth_user", "") or "")
-                if not user_id:
-                    return self._json(401, {"ok": False, "error": "no_session"})
-                try:
-                    conn = sqlite3.connect(str(_workframe_db_path()), timeout=3.0)
-                    conn.row_factory = sqlite3.Row
-                    rows = conn.execute(
-                        """SELECT id, workspace_id, user_id, agent_profile_id, provider, credential_type,
-                               credential_ref, label, is_active, created_at, updated_at
-                           FROM credential_bindings
-                           WHERE user_id = ? AND deleted_at IS NULL
-                           ORDER BY updated_at DESC, created_at DESC""",
-                        (user_id,),
-                    ).fetchall()
-                    conn.close()
-                except sqlite3.Error as exc:
-                    return self._json(500, {"ok": False, "error": f"db_error: {exc}"})
-                return self._json(200, {"ok": True, "credentials": [dict(row) for row in rows]})
-
-            if path == "/api/me/providers":
-                user_id = str(getattr(self, "auth_user", "") or "")
-                if not user_id:
-                    return self._json(401, {"ok": False, "error": "no_session"})
-                workspace_id = qs.get("workspace_id", [""])[0]
-                return self._json(200, list_user_providers(user_id, workspace_id))
-
+                        )
+                    self.send_response(302)
+                    self.send_header("Location", redirect_to)
+                    self.send_header("Set-Cookie", cookie_val)
+                    cors_origin = _cors_origin_for(self.headers)
+                    if cors_origin:
+                        self.send_header("Access-Control-Allow-Origin", cors_origin)
+                        self.send_header("Vary", "Origin")
+                    self.end_headers()
+                    return
+                except Exception as exc:
+                    return self._json(401, {"ok": False, "error": str(exc)})
             if path.startswith("/api/me/oauth/") and path.endswith("/status"):
                 parts = path.strip("/").split("/")
                 if len(parts) == 5 and parts[2] == "oauth" and parts[4] == "status":
@@ -16825,27 +17673,6 @@ class Handler(BaseHTTPRequestHandler):
                         return self._json(403, {"ok": False, "error": str(exc)})
                     return self._json(200, payload)
 
-            if path == "/api/me/cohort":
-                user_id = str(getattr(self, "auth_user", "") or "")
-                if not user_id:
-                    return self._json(401, {"ok": False, "error": "no_session"})
-                workspace_id = str(qs.get("workspace_id", [""])[0] or "").strip()
-                if not workspace_id:
-                    return self._json(400, {"ok": False, "error": "workspace_id_required"})
-                ws_id = _resolve_wid(workspace_id) or workspace_id
-                if not _user_is_workspace_member(user_id, ws_id):
-                    return self._json(403, {"ok": False, "error": "forbidden"})
-                cohort = ensure_user_agent_cohort(user_id, ws_id)
-                return self._json(
-                    200,
-                    {
-                        "ok": True,
-                        "workspace_id": ws_id,
-                        "user_id": user_id,
-                        "cohort": cohort,
-                    },
-                )
-
             if path.startswith("/api/rooms/") and path.endswith("/sessions"):
                 rid = path.strip("/").split("/")[-2]
                 user_id = str(getattr(self, "auth_user", "") or "")
@@ -16909,25 +17736,6 @@ class Handler(BaseHTTPRequestHandler):
                         return self._json(404, {"ok": False, "error": "workspace_not_found"})
                     return self._json(*_list_workspace_members(ws_id, self))
 
-            # --- Sprint J: User credentials (GET) ---
-            if path == "/api/user/credentials":
-                user_id = str(getattr(self, "auth_user", "") or "")
-                if not user_id:
-                    if DEV_LOCAL_UNSAFE:
-                        user_id = "dev"
-                    else:
-                        return self._json(401, {"ok": False, "error": "no_authenticated_user"})
-                try:
-                    conn = sqlite3.connect(str(AUTH_DB_PATH.parent / "workframe.db"), timeout=3.0)
-                    conn.row_factory = sqlite3.Row
-                    creds = conn.execute(
-                        "SELECT id, workspace_id, user_id, agent_profile_id, provider, credential_type, label, is_active, created_at, updated_at FROM credential_bindings WHERE user_id = ? AND deleted_at IS NULL ORDER BY created_at DESC",
-                        (user_id,)).fetchall()
-                    conn.close()
-                except Exception:
-                    creds = []
-                return self._json(200, {"ok": True, "credentials": [dict(c) for c in creds]})
-
             # --- Sprint I: Memory (GET) ---
             if path.startswith("/api/workspace/") and path.endswith("/memory"):
                 parts = path.strip("/").split("/")
@@ -17067,78 +17875,6 @@ class Handler(BaseHTTPRequestHandler):
                         pass
                     return
 
-            if path == "/api/meta":
-                return self._json(200, workframe_meta())
-            if path == "/api/agents":
-                return self._json(200, workframe_agents())
-            if path == "/api/snapshot":
-                return self._json(200, build_snapshot())
-            if path == "/api/activity/detail":
-                profile = qs.get("profile", [""])[0].strip()
-                tool_call_id = qs.get("tool_call_id", [""])[0].strip()
-                session_id = qs.get("session_id", [""])[0].strip()
-                message_id = qs.get("message_id", [""])[0].strip()
-                return self._json(200, activity_detail(profile, tool_call_id, session_id, message_id))
-            if path == "/api/board":
-                return self._json(200, board_list())
-            if path == "/api/content":
-                return self._json(200, content_list())
-            if path == "/api/content/get":
-                rel = qs.get("path", [""])[0]
-                reason = _workspace_protected_reason(rel)
-                if reason:
-                    return self._json(403, {"ok": False, "error": "protected_file", "reason": reason})
-                fp = _safe_content_path(rel)
-                if not fp or not fp.is_file():
-                    return self._json(404, {"error": "not found"})
-                text = fp.read_text(encoding="utf-8", errors="replace")
-                return self._json(200, {"path": rel, "content": text, "text": text})
-            if path == "/api/files/tree":
-                return self._json(200, {"root": files_tree()})
-            if path == "/api/files/list":
-                rel = qs.get("path", [""])[0]
-                reason = _workspace_protected_reason(rel)
-                if reason:
-                    return self._json(403, {"ok": False, "error": "protected_file", "reason": reason})
-                return self._json(200, files_list(rel))
-            if path == "/api/files/state":
-                return self._json(200, workspace_state())
-            if path == "/api/files/read":
-                rel = qs.get("path", [""])[0]
-                reason = _workspace_protected_reason(rel)
-                if reason:
-                    return self._json(403, {"ok": False, "error": "protected_file", "reason": reason})
-                return self._json(200, file_read(rel))
-            if path == "/api/files/raw":
-                rel = qs.get("path", [""])[0]
-                reason = _workspace_protected_reason(rel)
-                if reason:
-                    return self._json(403, {"ok": False, "error": "protected_file", "reason": reason})
-                try:
-                    data, mime = file_raw(rel)
-                except ValueError:
-                    return self._json(404, {"error": "not found"})
-                return self._send(200, data, mime)
-            if path == "/api/routes":
-                return self._json(200, load_routes())
-            if path == "/api/chat/messages":
-                profile = resolve_hermes_profile(qs.get("profile", [""])[0] or _primary_profile())
-                session = qs.get("session", [""])[0]
-                source_id = qs.get("source", ["ui"])[0]
-                return self._json(200, chat_messages(profile, session, source_id))
-            if path == "/api/chat/session":
-                profile = resolve_hermes_profile(qs.get("profile", [""])[0] or _primary_profile())
-                session = qs.get("session", [""])[0]
-                source_id = qs.get("source", ["ui"])[0]
-                return self._json(200, chat_session(profile, session, source_id))
-            if path == "/api/chat/resolve":
-                profile = resolve_validated_profile(qs.get("profile", [""])[0] or _primary_profile())
-                source_id = qs.get("source", ["ui"])[0]
-                client_id = qs.get("client", ["default"])[0]
-                return self._json(
-                    200,
-                    chat_resolve({"profile": profile, "source_id": source_id, "client_id": client_id}),
-                )
             if path == "/api/chat/bootstrap":
                 if not _role_allows(self, OWNER_ADMIN_ROLES):
                     return self._json(403, {"ok": False, "error": "forbidden", "required_role": "owner_or_admin"})
@@ -17150,28 +17886,6 @@ class Handler(BaseHTTPRequestHandler):
                 if not _role_allows(self, OWNER_ADMIN_ROLES):
                     return self._json(403, {"ok": False, "error": "forbidden", "required_role": "owner_or_admin"})
                 return self._json(200, hermes_bootstrap())
-            if path == "/api/hermes/skills":
-                return self._json(200, {"skills": hermes_skills()})
-            if path == "/api/hermes/commands":
-                return self._json(200, hermes_commands_catalog())
-            if path == "/api/hermes/usage":
-                return self._json(200, hermes_usage())
-            if path == "/api/hermes/profile":
-                return self._json(200, hermes_profile())
-            if path == "/api/hermes/debug":
-                return self._json(200, hermes_debug())
-            if path == "/api/hermes/insights":
-                return self._json(200, hermes_insights())
-            if path == "/api/hermes/gquota":
-                return self._json(200, hermes_gquota())
-            if path == "/api/hermes/models":
-                profile = qs.get("profile", [""])[0]
-                user_id = str(getattr(self, "auth_user", "") or "")
-                workspace_id = qs.get("workspace_id", [""])[0]
-                selection_only = qs.get("selection_only", ["0"])[0] in {"1", "true", "yes"}
-                payload = hermes_models(profile, user_id, workspace_id, selection_only=selection_only)
-                status = 200 if payload.get("ok", True) else 400
-                return self._json(status, payload)
             if path == "/api/hermes/profiles/status":
                 profile = resolve_validated_profile(qs.get("profile", [""])[0] or _primary_profile())
                 if SUPERVISOR_URL:
@@ -17311,33 +18025,6 @@ class Handler(BaseHTTPRequestHandler):
                         "credentials": [dict(r) for r in rows],
                     })
 
-            # GET /api/me/credentials — user-scoped credentials
-            if path == "/api/me/credentials" and self.command == "GET":
-                user_id = str(getattr(self, "auth_user", "") or "")
-                if not user_id:
-                    return self._json(401, {"ok": False, "error": "no_session"})
-                try:
-                    conn = sqlite3.connect(str(_workframe_db_path()), timeout=3.0)
-                    conn.row_factory = sqlite3.Row
-                    rows = conn.execute(
-                        """SELECT id, workspace_id, user_id, agent_profile_id, provider,
-                                  credential_type, credential_ref, label, is_active,
-                                  expires_at, created_by, created_at, updated_at
-                           FROM credential_bindings
-                           WHERE user_id = ? AND deleted_at IS NULL
-                           ORDER BY created_at DESC""",
-                        (user_id,),
-                    ).fetchall()
-                    conn.close()
-                except sqlite3.Error as exc:
-                    return self._json(500, {"ok": False, "error": str(exc)})
-                return self._json(200, {
-                    "ok": True,
-                    "scope": "user",
-                    "user_id": user_id,
-                    "credentials": [dict(r) for r in rows],
-                })
-
             # GET /api/agents/:agentId/credentials — agent-profile-scoped
             if path.startswith("/api/agents/") and path.endswith("/credentials") and self.command == "GET":
                 parts = path.strip("/").split("/")
@@ -17751,6 +18438,11 @@ class Handler(BaseHTTPRequestHandler):
 
         try:
             body = self._read_json()
+            post_body = body if isinstance(body, dict) else {}
+            self._post_qs = qs
+
+            if route_registry.dispatch_post(self, path, post_body):
+                return
 
             if path == "/api/install/email/test":
                 if not _install_window_open():
@@ -17913,365 +18605,6 @@ class Handler(BaseHTTPRequestHandler):
                 self._log_audit("vault_wipe", "vault", "secrets", f"deleted={deleted}")
                 return self._json(200, {"ok": True, "deleted": deleted, **credential_vault.vault_status()})
 
-            if path == "/api/auth/google/start":
-                invite_email = str(body.get("email") or "").strip().lower()
-                invite_token = str(body.get("invite_token") or "")
-                if invite_email:
-                    allowed, deny_meta = _email_allowed_to_authenticate(invite_email)
-                    if not allowed and not _invite_token_allows_email(invite_token, invite_email):
-                        self._log_audit(
-                            "login_denied_private",
-                            "user",
-                            invite_email,
-                            str(deny_meta.get("error") or ""),
-                        )
-                        return self._json(403, {"ok": False, **deny_meta})
-                try:
-                    payload = google_auth.start_google_auth(invite_email, invite_token)
-                    return self._json(200, payload)
-                except ValueError as exc:
-                    return self._json(400, {"ok": False, "error": str(exc)})
-
-            if path == "/api/auth/local-bootstrap":
-                if DEPLOYMENT_MODE != "single_user_local" or not _install_window_open():
-                    return self._json(403, {"ok": False, "error": "local_bootstrap_unavailable"})
-                display = str(body.get("display_name") or "Owner")
-                email = "owner@local.workframe"
-                try:
-                    result = _zk.create_session_for_email(email)
-                except Exception as exc:
-                    return self._json(500, {"ok": False, "error": str(exc)})
-                user_id = str(result["user_id"])
-                self.auth_user = user_id
-                self._ensure_user(user_id, display, email)
-                self._first_owner_bootstrap(user_id, display, email)
-                use_secure = _session_cookie_secure()
-                cookie_val = _zk.session_cookie_value(result["session_id"], secure=use_secure)
-                me_payload = _session_profile_payload(user_id)
-                return self._json(
-                    200,
-                    {
-                        "ok": True,
-                        "user_id": user_id,
-                        "session_id": result["session_id"],
-                        "refresh_token": result["refresh_token"],
-                        **(me_payload or {}),
-                    },
-                    extra_headers=[("Set-Cookie", cookie_val)],
-                )
-
-            # --- First-owner bootstrap (also wired into /api/auth/start) ---
-            if path == "/api/auth/bootstrap":
-                if not SECURE_MODE:
-                    return self._json(501, {"ok": False, "error": "bootstrap_requires_secure_mode"})
-                data = body if isinstance(body, dict) else {}
-                user_id = str(data.get("user_id", "") or secrets.token_hex(8))
-                user_email = str(data.get("email", ""))
-                user_display = str(data.get("display_name", "") or "Owner")
-                result = self._first_owner_bootstrap(user_id, user_display, user_email)
-                self._log_audit("user_created", "user", user_id, f"first-owner bootstrap: {user_display}")
-                return self._json(200, result)
-
-            # --- Setup endpoint (public, no auth) ---
-            if path == "/api/setup":
-                data = body if isinstance(body, dict) else {}
-                agent_name = str(data.get("agent_name", "")).strip()
-                workframe_name = str(data.get("workframe_name", "")).strip()
-                if not agent_name:
-                    return self._json(400, {"ok": False, "error": "agent_name required"})
-                try:
-                    db = _workframe_db()
-                    ws = db.execute("SELECT * FROM workspaces WHERE slug='default' AND deleted_at IS NULL").fetchone()
-                    if not ws:
-                        ws_id = str(uuid.uuid4())
-                        now = str(int(time.time()))
-                        workspace_display_name = workframe_name or "Default Workspace"
-                        ws_settings = stack_config.github_oauth_for_workspace_settings({})
-                        settings_json = json.dumps(ws_settings, sort_keys=True) if ws_settings else "{}"
-                        db.execute(
-                            "INSERT INTO workspaces (id, slug, display_name, description, owner_id, status, created_at, updated_at, settings_json) VALUES (?, 'default', ?, '', '', 'active', ?, ?, ?)",
-                            (ws_id, workspace_display_name, now, now, settings_json),
-                        )
-                        ws = db.execute("SELECT * FROM workspaces WHERE id = ?", (ws_id,)).fetchone()
-                    elif workframe_name and str(ws["display_name"] or "").strip() != workframe_name:
-                        now = str(int(time.time()))
-                        db.execute(
-                            "UPDATE workspaces SET display_name = ?, updated_at = ? WHERE id = ?",
-                            (workframe_name, now, ws["id"]),
-                        )
-                        ws = db.execute("SELECT * FROM workspaces WHERE id = ?", (ws["id"],)).fetchone()
-                    ws_id = ws["id"]
-                    existing_agents = db.execute("SELECT COUNT(*) AS c FROM agent_profiles WHERE workspace_id = ? AND deleted_at IS NULL", (ws_id,)).fetchone()
-                    if existing_agents and existing_agents["c"] > 0:
-                        if agent_name:
-                            now = str(int(time.time()))
-                            db.execute(
-                                """
-                                UPDATE agent_profiles
-                                SET display_name = ?, updated_at = ?
-                                WHERE workspace_id = ? AND is_native = 1 AND deleted_at IS NULL
-                                """,
-                                (agent_name, now, ws_id),
-                            )
-                            db.commit()
-                        db.close()
-                        return self._json(200, {"ok": True, "already_initialized": True, "workspace_id": ws_id})
-                    import re as _re
-                    agent_slug = _re.sub(r"[^a-z0-9-]", "", agent_name.lower().replace(" ", "-"))[:40]
-                    agent_id = str(uuid.uuid4())
-                    now = str(int(time.time()))
-                    db.execute(
-                        "INSERT INTO agent_profiles (id, workspace_id, slug, display_name, tagline, role, is_native, status, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, 1, 'active', ?, ?)",
-                        (agent_id, ws_id, agent_slug, agent_name, str(data.get("agent_personality", "")), "native", now, now),
-                    )
-                    room_id = str(uuid.uuid4())
-                    db.execute(
-                        "INSERT INTO rooms (id, workspace_id, name, slug, topic, room_type, status, created_at, updated_at) VALUES (?, ?, ?, ?, ?, 'channel', 'active', ?, ?)",
-                        (room_id, ws_id, "General", "general", "General discussion", now, now),
-                    )
-                    db.commit()
-                    db.close()
-                    hermes = _bootstrap_after_setup(str(data.get("agent_personality", "")))
-                    return self._json(
-                        200,
-                        {
-                            "ok": True,
-                            "workspace_id": ws_id,
-                            "agent_id": agent_id,
-                            "room_id": room_id,
-                            "hermes": hermes,
-                        },
-                    )
-                except Exception as exc:
-                    return self._json(500, {"ok": False, "error": str(exc)})
-
-            # --- Auth endpoints (zk-auth compatible) ---
-            if path == "/api/auth/start":
-                # POST /api/auth/start — email → OTP → send email (or return in dev)
-                email = str(body.get("email", "")).strip().lower()
-                if not email or "@" not in email:
-                    return self._json(400, {"ok": False, "error": "email required"})
-                client_ip = str(self.client_address[0] if self.client_address else "")
-                import auth_rate_limit
-
-                if not auth_rate_limit.allow_auth_request("start", client_ip, email):
-                    return self._json(429, {"ok": False, "error": "too_many_requests"})
-                allowed, deny_meta = _email_allowed_to_authenticate(email)
-                if not allowed:
-                    self._log_audit("login_denied_private", "user", email, str(deny_meta.get("error") or ""))
-                    return self._json(403, {"ok": False, **deny_meta})
-                try:
-                    base = APP_BASE_URL.strip().lower()
-                    loopback = base.startswith("http://127.0.0.1") or base.startswith("http://localhost")
-                    expose_otp = (
-                        os.environ.get("WORKFRAME_E2E") == "1"
-                        and _install_window_open()
-                        and loopback
-                    )
-                    result = _zk.start_email_verification(
-                        email,
-                        dev_local_unsafe=DEV_LOCAL_UNSAFE,
-                        expose_otp=expose_otp,
-                    )
-                except Exception as exc:
-                    return self._json(500, {"ok": False, "error": str(exc)})
-                if not DEV_LOCAL_UNSAFE and not expose_otp:
-                    result.pop("otp_code", None)
-                    result.pop("_dev_warning", None)
-                result.pop("_e2e_warning", None)
-                self._log_audit("otp_requested", "user", email, f"challenge={result.get('challenge_id','')}")
-                return self._json(200, {"ok": True, "status": "verification_sent", **result})
-
-            if path == "/api/auth/verify":
-                # POST /api/auth/verify — email + OTP → session
-                email = str(body.get("email", "")).strip().lower()
-                code = str(body.get("code", "")).strip()
-                if not email or not code:
-                    return self._json(400, {"ok": False, "error": "email and code required"})
-                client_ip = str(self.client_address[0] if self.client_address else "")
-                import auth_rate_limit
-
-                if not auth_rate_limit.allow_auth_request("verify", client_ip, email):
-                    return self._json(429, {"ok": False, "error": "too_many_requests"})
-                allowed, deny_meta = _email_allowed_to_authenticate(email)
-                if not allowed:
-                    self._log_audit("login_denied_private", "user", email, str(deny_meta.get("error") or ""))
-                    return self._json(403, {"ok": False, **deny_meta})
-                try:
-                    result = _zk.verify_email_code(email, code)
-                except ValueError as exc:
-                    self._log_audit("login_failed", "user", email, f"verify failed: {exc}")
-                    return self._json(401, {"ok": False, "error": str(exc)})
-                except Exception as exc:
-                    return self._json(500, {"ok": False, "error": str(exc)})
-                # Set session cookie
-                use_secure = _session_cookie_secure()
-                cookie_val = _zk.session_cookie_value(result["session_id"], secure=use_secure)
-                # Store user_id on handler for role checks
-                self.auth_user = result["user_id"]
-                self._ensure_user(result["user_id"], email, email)
-                self._log_audit("login", "session", result["session_id"],
-                                f"user={result['user_id']} new={result['is_new_user']}")
-                me_payload = _session_profile_payload(result["user_id"])
-                return self._json(
-                    200,
-                    {
-                        "ok": True,
-                        "user_id": result["user_id"],
-                        "session_id": result["session_id"],
-                        "refresh_token": result["refresh_token"],
-                        "expires_at": result["expires_at"],
-                        "is_new_user": result["is_new_user"],
-                        **(me_payload or {}),
-                    },
-                    extra_headers=[("Set-Cookie", cookie_val)],
-                )
-
-            if path == "/api/auth/logout":
-                # POST /api/auth/logout — revoke session
-                sid = _session_id_from_request(self)
-                user_id = str(getattr(self, "auth_user", "") or "")
-                if sid:
-                    try:
-                        _zk.logout_session(sid)
-                    except Exception:
-                        pass
-                use_secure = _session_cookie_secure()
-                cookie_val = _zk.clear_session_cookie(secure=use_secure)
-                self._log_audit("logout", "session", sid, f"user={user_id}")
-                return self._json(200, {"ok": True}, extra_headers=[("Set-Cookie", cookie_val)])
-
-            if path == "/api/auth/refresh":
-                # POST /api/auth/refresh — refresh token rotation or cookie session extend
-                refresh_token = str(body.get("refresh_token", "")).strip()
-                if not refresh_token:
-                    sid = _session_id_from_request(self)
-                    if not sid:
-                        return self._json(400, {"ok": False, "error": "refresh_token required"})
-                    validated = _zk.validate_session_token(sid)
-                    if not validated:
-                        return self._json(401, {"ok": False, "error": "session_expired"})
-                    use_secure = _session_cookie_secure()
-                    cookie_val = _zk.session_cookie_value(validated["session_id"], secure=use_secure)
-                    return self._json(
-                        200,
-                        {
-                            "ok": True,
-                            "user_id": validated["user_id"],
-                            "session_id": validated["session_id"],
-                            "expires_at": validated["expires_at"],
-                        },
-                        extra_headers=[("Set-Cookie", cookie_val)],
-                    )
-                try:
-                    result = _zk.refresh_session(refresh_token)
-                except ValueError as exc:
-                    return self._json(401, {"ok": False, "error": str(exc)})
-                except Exception as exc:
-                    return self._json(500, {"ok": False, "error": str(exc)})
-                # Set new session cookie
-                use_secure = _session_cookie_secure()
-                cookie_val = _zk.session_cookie_value(result["session_id"], secure=use_secure)
-                self._log_audit("session_refreshed", "session", result["session_id"],
-                                f"user={result['user_id']}")
-                return self._json(
-                    200,
-                    {
-                        "ok": True,
-                        "user_id": result["user_id"],
-                        "session_id": result["session_id"],
-                        "refresh_token": result["refresh_token"],
-                        "expires_at": result["expires_at"],
-                    },
-                    extra_headers=[("Set-Cookie", cookie_val)],
-                )
-
-            if path == "/api/me/credentials":
-                user_id = str(getattr(self, "auth_user", "") or "")
-                if not user_id:
-                    return self._json(401, {"ok": False, "error": "no_session"})
-                provider = str(body.get("provider", "")).strip()
-                credential_type = str(body.get("credential_type", "api_key")).strip() or "api_key"
-                secret = str(body.get("secret", "")).strip()
-                spec = _catalog_provider(provider)
-                if spec:
-                    credential_type = str(spec.get("connect_mode") or credential_type)
-                env_var = str(body.get("env_var", "")).strip() or (
-                    str(spec.get("env_var") or "") if spec else ""
-                ) or _default_credential_env_var(provider, credential_type)
-                label = str(body.get("label", "")).strip() or env_var
-                if not provider:
-                    return self._json(400, {"ok": False, "error": "provider required"})
-                if not secret:
-                    return self._json(400, {"ok": False, "error": "secret required"})
-                payload = _store_user_credential(user_id, provider, credential_type, secret, env_var, label)
-                cred_ref = str(payload["credential_ref"])
-                now = _utc_now()
-                try:
-                    conn = sqlite3.connect(str(_workframe_db_path()), timeout=3.0)
-                    conn.row_factory = sqlite3.Row
-                    existing = conn.execute(
-                        """SELECT id FROM credential_bindings
-                           WHERE user_id = ? AND provider = ? AND credential_type = ?
-                             AND credential_ref = ? AND deleted_at IS NULL
-                           ORDER BY updated_at DESC, created_at DESC LIMIT 1""",
-                        (user_id, provider, credential_type, cred_ref),
-                    ).fetchone()
-                    if existing:
-                        cred_id = str(existing["id"])
-                        conn.execute(
-                            """UPDATE credential_bindings
-                               SET label = ?, is_active = 1, updated_at = ?, deleted_at = NULL
-                               WHERE id = ?""",
-                            (label, now, cred_id),
-                        )
-                    else:
-                        cred_id = str(payload["credential_id"])
-                        conn.execute(
-                            """INSERT INTO credential_bindings
-                               (id, workspace_id, user_id, agent_profile_id, provider, credential_type,
-                                credential_ref, label, is_active, created_by, created_at, updated_at)
-                               VALUES (?,?,?,?,?,?,?,?,?,?,?,?)""",
-                            (cred_id, None, user_id, None, provider, credential_type, cred_ref, label, 1, user_id, now, now),
-                        )
-                    conn.execute(
-                        """UPDATE credential_bindings
-                           SET is_active = 0, deleted_at = ?, updated_at = ?
-                           WHERE user_id = ? AND provider = ? AND deleted_at IS NULL AND id != ?""",
-                        (now, now, user_id, provider, cred_id),
-                    )
-                    conn.commit()
-                    conn.close()
-                except sqlite3.Error as exc:
-                    return self._json(500, {"ok": False, "error": f"db_error: {exc}"})
-                self._log_audit("credential_stored", "credential_binding", cred_id, f"provider={provider}")
-                health: dict[str, Any] = {}
-                if provider == "openrouter":
-                    secret_probe = _credential_secret(
-                        {
-                            "credential_ref": cred_ref,
-                            "scope": "user",
-                            "user_id": user_id,
-                        },
-                        user_id,
-                    )
-                    if secret_probe:
-                        health = openrouter_catalog.probe_account(secret_probe)
-                _bootstrap_model_after_llm_connect(user_id, str(body.get("workspace_id") or ""), provider)
-                return self._json(200, {
-                    "ok": True,
-                    "credential_id": cred_id,
-                    "provider": provider,
-                    "credential_type": credential_type,
-                    "label": label,
-                    "is_active": 1,
-                    "user_id": user_id,
-                    "created_at": now,
-                    "updated_at": now,
-                    "health": health,
-                    **payload,
-                })
-
             if path.startswith("/api/me/oauth/") and path.endswith("/start"):
                 parts = path.strip("/").split("/")
                 if len(parts) == 5 and parts[2] == "oauth" and parts[4] == "start":
@@ -18282,18 +18615,6 @@ class Handler(BaseHTTPRequestHandler):
                     workspace_id = str(body.get("workspace_id") or "")
                     return self._json(200, start_user_oauth(user_id, provider_id, workspace_id))
 
-            if path == "/api/me/telegram/link":
-                user_id = str(getattr(self, "auth_user", "") or "")
-                if not user_id:
-                    return self._json(401, {"ok": False, "error": "no_session"})
-                result = platform_auth.verify_telegram_login(body if isinstance(body, dict) else {})
-                if not result.get("ok"):
-                    return self._json(400, {"ok": False, "error": result.get("error") or "telegram_link_failed"})
-                patch = result.get("platform_ids") if isinstance(result.get("platform_ids"), dict) else {}
-                if patch:
-                    _merge_user_platform_ids(user_id, {str(k): str(v) for k, v in patch.items()})
-                return self._json(200, {"ok": True, "provider": "telegram", "platform_ids": patch})
-
             if path.startswith("/api/me/providers/") and path.endswith("/disconnect"):
                 parts = path.strip("/").split("/")
                 if len(parts) == 5 and parts[2] == "providers" and parts[4] == "disconnect":
@@ -18429,33 +18750,6 @@ class Handler(BaseHTTPRequestHandler):
                         "credentials": [dict(r) for r in rows],
                     })
 
-            # GET /api/me/credentials — user-scoped credentials
-            if path == "/api/me/credentials" and self.command == "GET":
-                user_id = str(getattr(self, "auth_user", "") or "")
-                if not user_id:
-                    return self._json(401, {"ok": False, "error": "no_session"})
-                try:
-                    conn = sqlite3.connect(str(_workframe_db_path()), timeout=3.0)
-                    conn.row_factory = sqlite3.Row
-                    rows = conn.execute(
-                        """SELECT id, workspace_id, user_id, agent_profile_id, provider,
-                                  credential_type, credential_ref, label, is_active,
-                                  expires_at, created_by, created_at, updated_at
-                           FROM credential_bindings
-                           WHERE user_id = ? AND deleted_at IS NULL
-                           ORDER BY created_at DESC""",
-                        (user_id,),
-                    ).fetchall()
-                    conn.close()
-                except sqlite3.Error as exc:
-                    return self._json(500, {"ok": False, "error": str(exc)})
-                return self._json(200, {
-                    "ok": True,
-                    "scope": "user",
-                    "user_id": user_id,
-                    "credentials": [dict(r) for r in rows],
-                })
-
             # GET /api/agents/:agentId/credentials — agent-profile-scoped credentials
             if path.startswith("/api/agents/") and path.endswith("/credentials") and self.command == "GET":
                 parts = path.strip("/").split("/")
@@ -19124,169 +19418,6 @@ class Handler(BaseHTTPRequestHandler):
                     self._log_audit("grant_created", "credential_grant", grant_id, f"workspace={ws_id} grantee={grantee_type}:{grantee_id}")
                     return self._json(201, {"ok": True, "grant_id": grant_id})
 
-            if path == "/api/hermes/commands/exec":
-                if not _check_auth(self):
-                    return self._json(401, {"error": "unauthorized"})
-                line = str(body.get("line", "")).strip()
-                if not line:
-                    return self._json(400, {"error": "line required"})
-                return self._json(200, hermes_commands_exec(line))
-            if path == "/api/hermes/gateway/exec":
-                if not _check_auth(self):
-                    return self._json(401, {"error": "unauthorized"})
-                line = str(body.get("line", "")).strip()
-                profile = str(body.get("profile", "")).strip()
-                if not line:
-                    return self._json(400, {"error": "line required"})
-                user_id = str(getattr(self, "auth_user", "") or "")
-                workspace_id = str(body.get("workspace_id", "") or "")
-                return self._json(
-                    200,
-                    hermes_gateway_exec(line, profile, user_id=user_id, workspace_id=workspace_id),
-                )
-            if path == "/api/chat/stop":
-                if not _check_auth(self):
-                    return self._json(401, {"error": "unauthorized"})
-                profile = resolve_validated_profile(str(body.get("profile") or _primary_profile()))
-                run_id = str(body.get("run_id") or "").strip()
-                # If no run_id provided, find the latest active run for this profile
-                if not run_id:
-                    run_id = _latest_active_run_id(profile)
-                if not run_id:
-                    return self._json(400, {"error": "no active run to stop"})
-                return self._json(200, profile_gateway_stop(profile, run_id))
-            if path == "/api/chat/steer":
-                if not _check_auth(self):
-                    return self._json(401, {"error": "unauthorized"})
-                profile = resolve_validated_profile(str(body.get("profile") or _primary_profile()))
-                run_id = str(body.get("run_id") or "").strip()
-                text = str(body.get("text") or "").strip()
-                if not text:
-                    return self._json(400, {"error": "text required"})
-                # If no run_id provided, find the latest active run
-                if not run_id:
-                    run_id = _latest_active_run_id(profile)
-                return self._json(200, profile_gateway_steer(profile, run_id or "", text))
-            if path == "/api/hermes/model":
-                if not _check_auth(self):
-                    return self._json(401, {"error": "unauthorized"})
-                model_id = str(body.get("model", "")).strip()
-                profile = str(body.get("profile", "")).strip()
-                user_id = str(getattr(self, "auth_user", "") or "")
-                workspace_id = str(body.get("workspace_id", "")).strip()
-                selection_only = bool(body.get("selection_only"))
-                if not model_id:
-                    return self._json(400, {"error": "model required"})
-                if profile and not selection_only:
-                    try:
-                        _bootstrap_profile_providers(_resolve_models_profile(profile), user_id, workspace_id)
-                    except ValueError as exc:
-                        return self._json(400, {"ok": False, "error": str(exc)})
-                return self._json(
-                    200,
-                    hermes_model_set(
-                        profile,
-                        model_id,
-                        user_id,
-                        workspace_id,
-                        selection_only=selection_only,
-                    ),
-                )
-            if path == "/api/hermes/model/apply-default":
-                if not _check_auth(self):
-                    return self._json(401, {"error": "unauthorized"})
-                if not _role_allows(self, OWNER_ADMIN_ROLES):
-                    return self._json(403, {"ok": False, "error": "forbidden", "required_role": "owner_or_admin"})
-                return self._json(200, hermes_apply_default_model_config())
-            if path == "/api/hermes/fallback-chain":
-                if not _check_auth(self):
-                    return self._json(401, {"error": "unauthorized"})
-                profile = str(body.get("profile", "")).strip()
-                chain = body.get("chain", [])
-                selection_only = bool(body.get("selection_only"))
-                user_id = str(getattr(self, "auth_user", "") or "")
-                if not isinstance(chain, list):
-                    return self._json(400, {"error": "chain must be a list"})
-                if not selection_only and not _role_allows(self, OWNER_ADMIN_ROLES):
-                    return self._json(403, {"ok": False, "error": "forbidden", "required_role": "owner_or_admin"})
-                return self._json(
-                    200,
-                    hermes_fallback_chain_set(
-                        profile,
-                        chain,
-                        selection_only=selection_only,
-                        user_id=user_id,
-                    ),
-                )
-            if path == "/api/board":
-                if not _check_auth(self):
-                    return self._json(401, {"error": "unauthorized"})
-                return self._json(201, board_create(body))
-            if path == "/api/board/update":
-                if not _check_auth(self):
-                    return self._json(401, {"error": "unauthorized"})
-                task_id = qs.get("id", [""])[0]
-                if not task_id:
-                    return self._json(400, {"error": "id required"})
-                return self._json(200, board_update(task_id, body))
-            if path == "/api/board/delete":
-                if not _check_auth(self):
-                    return self._json(401, {"error": "unauthorized"})
-                task_id = qs.get("id", [""])[0]
-                if not task_id:
-                    return self._json(400, {"error": "id required"})
-                board_delete(task_id)
-                return self._json(200, {"ok": True})
-            if path == "/api/content/save":
-                if not _check_auth(self):
-                    return self._json(401, {"error": "unauthorized"})
-                rel = str(body.get("path") or "").strip()
-                reason = _workspace_protected_reason(rel)
-                if reason:
-                    return self._json(403, {"ok": False, "error": "protected_file", "reason": reason})
-                content = str(body.get("content") or "")
-                fp = _safe_content_path(rel)
-                if not fp:
-                    return self._json(400, {"error": "invalid path"})
-                fp.parent.mkdir(parents=True, exist_ok=True)
-                fp.write_text(content, encoding="utf-8")
-                _bump_workspace_state(fp)
-                return self._json(200, {"ok": True, "path": rel.replace("\\", "/")})
-            if path == "/api/content/delete":
-                if not _check_auth(self):
-                    return self._json(401, {"error": "unauthorized"})
-                rel = qs.get("path", [""])[0] or str(body.get("path") or "")
-                reason = _workspace_protected_reason(rel)
-                if reason:
-                    return self._json(403, {"ok": False, "error": "protected_file", "reason": reason})
-                fp = _safe_content_path(rel)
-                if not fp or not fp.is_file():
-                    return self._json(404, {"error": "not found"})
-                fp.unlink()
-                _bump_workspace_state(fp.parent)
-                return self._json(200, {"ok": True})
-            if path == "/api/files/write":
-                if not _check_auth(self):
-                    return self._json(401, {"error": "unauthorized"})
-                rel = str(body.get("path") or "").strip()
-                reason = _workspace_protected_reason(rel)
-                if reason:
-                    return self._json(403, {"ok": False, "error": "protected_file", "reason": reason})
-                content = str(body.get("content") or "")
-                return self._json(200, file_write(rel, content))
-            if path == "/api/files/upload":
-                if not _check_auth(self):
-                    return self._json(401, {"error": "unauthorized"})
-                rel = str(body.get("path") or "").strip()
-                reason = _workspace_protected_reason(rel)
-                if reason:
-                    return self._json(403, {"ok": False, "error": "protected_file", "reason": reason})
-                content_b64 = str(body.get("content_base64") or body.get("content") or "")
-                return self._json(200, file_upload_binary(rel, content_b64))
-            if path == "/api/chat/dispatch":
-                if not _check_auth(self):
-                    return self._json(401, {"error": "unauthorized"})
-                return self._json(200, chat_dispatch(body))
             if path == "/api/hermes/profiles/create":
                 if not _check_auth(self):
                     return self._json(401, {"error": "unauthorized"})