create-workframe 0.1.14 → 0.1.16

package/workframe-api/llm_error_glossary.py

@@ -32,7 +32,7 @@ PLAYBOOK: dict[str, dict[str, Any]] = {
     },
     "provider_invalid_key": {
         "message": "Your API key was rejected by the provider.",
-        "hint": "Reset the key at your provider, then paste it again under Connected accounts.",
+        "hint": "The key may be expired or revoked. Paste a new one under Settings → Integrations.",
         "action": _ACTIONS["open_providers"],
         "action_label": "Update API key",
         "secondary_action": _ACTIONS["openrouter_keys"],
@@ -95,6 +95,38 @@ PLAYBOOK: dict[str, dict[str, Any]] = {
 }
 
 
+_PROVIDER_LABELS: dict[str, str] = {
+    "openrouter": "OpenRouter",
+    "openai": "OpenAI",
+    "anthropic": "Anthropic",
+    "google": "Google",
+    "deepseek": "DeepSeek",
+}
+
+
+def _provider_label(provider: str) -> str:
+    key = str(provider or "openrouter").strip().lower()
+    return _PROVIDER_LABELS.get(key, key.title() or "Provider")
+
+
+def tailor_provider_entry(entry: dict[str, Any], provider: str) -> dict[str, Any]:
+    """Agent-facing copy when a provider rejects credentials."""
+    if str(entry.get("code") or "") != "provider_invalid_key":
+        return entry
+    label = _provider_label(provider)
+    out = dict(entry)
+    out["message"] = (
+        f"I couldn't authenticate with {label} — your API key may be expired or revoked."
+    )
+    out["hint"] = (
+        f"Open Settings → Integrations to paste a new {label} key, then send your message again."
+    )
+    if str(provider or "").strip().lower() == "openrouter":
+        out["secondary_action"] = _ACTIONS["openrouter_keys"]
+        out["secondary_action_label"] = "Manage OpenRouter keys"
+    return out
+
+
 def playbook_entry(code: str, **overrides: Any) -> dict[str, Any]:
     """Return a copy of a playbook row with optional string format overrides."""
     base = dict(PLAYBOOK.get(code) or PLAYBOOK["unknown_provider_error"])
@@ -156,8 +188,17 @@ def classify_upstream(
     low = msg.lower()
     model_id = model or _model_from_text(msg)
 
-    if status == 401 or "invalid api key" in low or "incorrect api key" in low or "unauthorized" in low:
-        return playbook_entry("provider_invalid_key", provider=provider)
+    if (
+        status == 401
+        or "invalid api key" in low
+        or "incorrect api key" in low
+        or "unauthorized" in low
+        or "user not found" in low
+    ):
+        return tailor_provider_entry(
+            playbook_entry("provider_invalid_key", provider=provider),
+            provider,
+        )
     if status == 402 or "insufficient" in low and "credit" in low or "payment required" in low:
         return playbook_entry("provider_no_credits", provider=provider)
     if status == 429 or "rate limit" in low:
@@ -197,11 +238,18 @@ def classify_exception_text(text: str) -> dict[str, Any]:
         return classify_upstream(429, raw)
     if "credit" in low:
         return classify_upstream(402, raw)
-    if "api key" in low or "unauthorized" in low:
+    if "api key" in low or "unauthorized" in low or "user not found" in low:
         return classify_upstream(401, raw)
     return playbook_entry("unknown_provider_error", detail=raw[:200])
 
 
+def classify_stream_error(text: str, *, provider: str = "openrouter") -> dict[str, Any]:
+    """Classify upstream/Hermes failure text into UI notice payload."""
+    entry = classify_exception_text(str(text or "").strip())
+    entry = tailor_provider_entry(entry, provider)
+    return notice_payload(entry)
+
+
 def notice_payload(entry: dict[str, Any]) -> dict[str, Any]:
     """SSE/JSON-safe dict for UI."""
     out: dict[str, Any] = {
@@ -233,4 +281,10 @@ if __name__ == "__main__":
     assert e2["code"] == "no_llm_provider"
     e3 = classify_upstream(401, b'{"error":"Invalid API key"}')
     assert e3["code"] == "provider_invalid_key"
+    e4 = classify_exception_text("HTTP 401: User not found.")
+    assert e4["code"] == "provider_invalid_key"
+    assert "OpenRouter" in e4["message"] or "authenticate" in e4["message"]
+    p = classify_stream_error("HTTP 401: User not found.", provider="openrouter")
+    assert p["code"] == "provider_invalid_key"
+    assert p.get("action", {}).get("type") == "open_settings"
     print("llm_error_glossary ok")

package/workframe-api/mention_invoke.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import json
 import sqlite3
 import time
+import urllib.error
 import urllib.parse
 import urllib.request
 import uuid
@@ -70,14 +71,22 @@ def _invoke_room_agent_mention(
     template_slug = str(agent_row.get("slug") or "").strip()
     agent_db_id = str(agent_row.get("id") or "").strip()
     agent_name = str(agent_row.get("display_name") or template_slug).strip() or template_slug
-    if triggered_by_user_id:
-        personal = _srv()._runtime_display_label(triggered_by_user_id, template_slug, workspace_id)
-        if personal:
-            agent_name = personal
     if not template_slug or not agent_db_id:
         return
-    hermes_slug = _srv()._runtime_profile_slug(triggered_by_user_id, template_slug)
-    _srv().ensure_runtime_profile(hermes_slug, template_slug, triggered_by_user_id, workspace_id)
+    # Shared rooms use the native/template Hermes profile and one shared
+    # session. The triggering user's vault credential is overlaid per turn
+    # below; do not switch the room onto that user's private runtime profile.
+    hermes_slug = template_slug
+    display_model = str(agent_row.get("model_name") or "").strip()
+    display_provider = str(agent_row.get("model_provider") or "").strip()
+    if not display_model:
+        display_model = str(_srv()._read_model_block(hermes_slug).get("default") or "").strip()
+    if not display_provider:
+        display_provider = _srv()._llm_billing_provider(
+            hermes_slug,
+            user_id=triggered_by_user_id,
+            workspace_id=workspace_id,
+        )
 
     turn_id = str(uuid.uuid4())
     segments: list[dict[str, Any]] = []
@@ -200,6 +209,8 @@ def _invoke_room_agent_mention(
                 "agent_slug": hermes_slug,
                 "agent_name": agent_name,
                 "agent_profile_id": agent_db_id,
+                "model": display_model,
+                "llm_provider": display_provider,
                 "triggered_by_user_id": triggered_by_user_id,
             },
         )
@@ -276,7 +287,7 @@ def _invoke_room_agent_mention(
             if not auth_decision.allowed:
                 fail_turn(
                     "I can't reply yet — connect an LLM provider in Profile → Connect accounts.",
-                    persist=False,
+                    persist=True,
                 )
                 return
 
@@ -299,28 +310,79 @@ def _invoke_room_agent_mention(
             "Content-Type": "application/json",
         }
         req = urllib.request.Request(url, data=upstream_body, headers=headers, method="POST")
-        upstream = urllib.request.urlopen(req, timeout=3600)
-
         final_text = ""
+        upstream = None
         try:
-            publish_update(force=True, status="thinking")
-            for event_name, data in chat_stream._iter_profile_stream_frames(upstream):
-                segments[:] = chat_stream._live_reduce_stream_event(segments, event_name, data)
-                if event_name in ("message.delta", "assistant.delta"):
-                    final_text += chat_stream._live_stream_text(data)
-                    publish_update(status="writing")
-                elif event_name in ("thinking.delta", "reasoning.delta"):
-                    publish_update(status="thinking")
-                elif event_name == "tool.started":
-                    publish_update(force=True, status=f"tool:{data.get('tool_name') or 'tool'}")
-                elif event_name in ("tool.completed", "tool.failed", "tool.progress"):
-                    publish_update(force=True)
-                elif event_name in ("message.complete", "assistant.completed"):
-                    final_text = str(data.get("content") or data.get("text") or final_text)
-                    publish_update(force=True, status="writing")
-            publish_update(force=True)
-        finally:
-            upstream.close()
+            upstream = urllib.request.urlopen(req, timeout=3600)
+        except urllib.error.HTTPError as exc:
+            # Older Hermes runtimes expose the session chat endpoint but not
+            # the streaming variant. Room mentions should still work there;
+            # use the same non-stream request as the DM path.
+            if exc.code != 404:
+                raise
+            status, data = _srv()._profile_api_request(
+                hermes_slug,
+                "POST",
+                f"/api/sessions/{urllib.parse.quote(session_id, safe='')}/chat",
+                turn_body,
+            )
+            error_obj = data.get("error") if isinstance(data, dict) else None
+            error_code = error_obj.get("code") if isinstance(error_obj, dict) else ""
+            if status == 404 and error_code == "session_not_found":
+                # Hermes session state can be reset independently of the
+                # Workframe DB. Rebind this room once, then retry the turn.
+                session = lane_bindings.profile_chat_session(
+                    hermes_slug,
+                    {
+                        "room_id": room_id,
+                        "source_id": "room",
+                        "client_id": room_id,
+                        "workspace_id": workspace_id,
+                        "new_session": True,
+                    },
+                    triggered_by_user_id,
+                )
+                session_id = str(session.get("session_id") or "").strip()
+                if not session_id:
+                    raise ValueError("session_bootstrap_failed: could not recreate agent session for this room")
+                turn_body = profile_gateway._profile_turn_payload(hermes_slug, user_text, room_id)
+                _inject_turn_credentials(turn_body, triggered_by_user_id, workspace_id, provider)
+                status, data = _srv()._profile_api_request(
+                    hermes_slug,
+                    "POST",
+                    f"/api/sessions/{urllib.parse.quote(session_id, safe='')}/chat",
+                    turn_body,
+                )
+            if status >= 300:
+                raise ValueError(f"session chat failed: {data}")
+            if isinstance(data, dict):
+                message = data.get("message")
+                if isinstance(message, dict):
+                    final_text = str(message.get("content") or message.get("text") or "")
+                if not final_text:
+                    final_text = str(data.get("content") or data.get("text") or "")
+            publish_update(force=True, status="writing")
+
+        if upstream is not None:
+            try:
+                publish_update(force=True, status="thinking")
+                for event_name, data in chat_stream._iter_profile_stream_frames(upstream):
+                    segments[:] = chat_stream._live_reduce_stream_event(segments, event_name, data)
+                    if event_name in ("message.delta", "assistant.delta"):
+                        final_text += chat_stream._live_stream_text(data)
+                        publish_update(status="writing")
+                    elif event_name in ("thinking.delta", "reasoning.delta"):
+                        publish_update(status="thinking")
+                    elif event_name == "tool.started":
+                        publish_update(force=True, status=f"tool:{data.get('tool_name') or 'tool'}")
+                    elif event_name in ("tool.completed", "tool.failed", "tool.progress"):
+                        publish_update(force=True)
+                    elif event_name in ("message.complete", "assistant.completed"):
+                        final_text = str(data.get("content") or data.get("text") or final_text)
+                        publish_update(force=True, status="writing")
+                publish_update(force=True)
+            finally:
+                upstream.close()
 
         assistant = final_text.strip() or chat_stream._segments_to_reply_text(segments)
         if not assistant:

package/workframe-api/model_surface.py

@@ -493,7 +493,7 @@ def _apply_model_for_billing_provider(
     ok_provider, _ = _set_profile_model_provider(profile, "custom")
     if not ok_provider:
         return False
-    _set_profile_model_base_url(profile, _srv()._llm_proxy_base_url(billing))
+    _srv()._set_profile_model_base_url(profile, _srv()._llm_proxy_base_url(billing))
     return True
 
 

package/workframe-api/provider_bindings.py

@@ -434,6 +434,33 @@ def _parse_device_oauth_log(text: str) -> dict[str, str | None]:
     return {"verification_uri": verification_uri, "user_code": user_code}
 
 
+def _device_oauth_error_from_log(log_text: str) -> str | None:
+    clean = _strip_ansi(log_text).strip()
+    if not clean:
+        return None
+    lowered = clean.lower()
+    auth_err = re.search(r"AuthError:\s*(.+)", clean)
+    if auth_err:
+        return auth_err.group(1).strip()[:500]
+    if "rate-limit" in lowered or "rate limiting" in lowered or "http 429" in lowered or re.search(r"\b429\b", lowered):
+        return (
+            "OpenAI is rate-limiting Codex login requests (HTTP 429). "
+            "Wait a minute and try again."
+        )
+    if any(token in lowered for token in ("login timed out", "login cancelled", "oauth_start_failed")):
+        lines = [line.strip() for line in clean.splitlines() if line.strip()]
+        return (lines[-1] if lines else "OAuth failed")[:500]
+    if "traceback" in lowered and any(token in lowered for token in ("error", "exception", "failed")):
+        for line in reversed(clean.splitlines()):
+            stripped = line.strip()
+            if not stripped or stripped.startswith("File ") or "Traceback" in stripped:
+                continue
+            if stripped.endswith(":") and "Error" not in stripped:
+                continue
+            return stripped[:500]
+    return None
+
+
 def _sync_user_oauth_provider_to_runtime_profiles(user_id: str, hermes_auth_id: str) -> None:
     if not _hermes_oauth_tokens_present(user_id, hermes_auth_id):
         return
@@ -527,11 +554,13 @@ def _start_device_oauth(user_id: str, provider_id: str, spec: dict[str, Any]) ->
     except (RuntimeError, ValueError) as exc:
         return {"ok": False, "provider": provider_id, "error": str(exc)}
     if rc != 0:
+        output = (out or "").strip()
         return {
             "ok": False,
             "provider": provider_id,
             "error": "oauth_start_failed",
-            "output": (out or "").strip(),
+            "output": output,
+            "message": _device_oauth_error_from_log(output) or output[-500:] or "Could not start OAuth",
         }
     with _oauth_device_lock:
         _oauth_device_sessions[session_id] = {
@@ -583,6 +612,19 @@ def device_oauth_status(user_id: str, provider_id: str, session_id: str) -> dict
     if patch:
         _device_oauth_session_patch(session_id, patch)
         sess.update(patch)
+    log_error = _device_oauth_error_from_log(log_text)
+    if log_error:
+        _device_oauth_session_patch(session_id, {"status": "error"})
+        return {
+            "ok": False,
+            "provider": provider_id,
+            "session_id": session_id,
+            "status": "error",
+            "error": "oauth_failed",
+            "message": log_error,
+            "verification_uri": sess.get("verification_uri"),
+            "user_code": sess.get("user_code"),
+        }
     if _hermes_oauth_tokens_present(user_id, hermes_auth_id):
         if not sess.get("finalized"):
             _finalize_hermes_device_oauth(user_id, provider_id, spec)
@@ -617,7 +659,7 @@ def device_oauth_status(user_id: str, provider_id: str, session_id: str) -> dict
             "session_id": session_id,
             "status": "error",
             "error": "oauth_failed",
-            "message": _strip_ansi(log_text).strip()[-500:] or "OAuth failed",
+            "message": _device_oauth_error_from_log(log_text) or _strip_ansi(log_text).strip()[-500:] or "OAuth failed",
             "verification_uri": sess.get("verification_uri"),
             "user_code": sess.get("user_code"),
         }

package/workframe-api/provider_bootstrap.py

@@ -130,6 +130,15 @@ def _user_llm_providers_for_picker(user_id: str) -> set[str]:
     return set(connected)
 
 
+def invalidate_user_llm_picker_cache(user_id: str = "") -> None:
+    """Forget cached provider availability after a credential mutation."""
+    user = str(user_id or "").strip()
+    if user:
+        _srv()._user_llm_picker_cache.pop(user, None)
+    else:
+        _srv()._user_llm_picker_cache.clear()
+
+
 def _user_has_llm_provider(user_id: str) -> bool:
     return bool(_srv()._user_llm_providers_for_picker(user_id))
 

package/workframe-api/provider_catalog.py

@@ -12,7 +12,7 @@ PROVIDER_CONNECT_CATALOG: tuple[dict[str, Any], ...] = (
         "category": "llm",
         "connect_mode": "api_key",
         "env_var": "OPENROUTER_API_KEY",
-        "description": "Primary LLM router — any model via one API key.",
+        "description": "Primary LLM router — any model via one API key.",
     },
     {
         "id": "anthropic",
@@ -104,7 +104,7 @@ PROVIDER_CONNECT_CATALOG: tuple[dict[str, Any], ...] = (
         "oauth_provider": "github",
         "hermes_auth_id": "github",
         "user_only": True,
-        "description": "OAuth (admin registers app) or fine-grained PAT — repo push and GitHub API.",
+        "description": "OAuth (admin registers app) or fine-grained PAT — repo push and GitHub API.",
     },
     {
         "id": "stripe",
@@ -114,7 +114,7 @@ PROVIDER_CONNECT_CATALOG: tuple[dict[str, Any], ...] = (
         "env_var": "STRIPE_SECRET_KEY",
         "oauth_provider": "stripe",
         "user_only": True,
-        "description": "Connect your Stripe account — charges, customers, and billing tools.",
+        "description": "Connect your Stripe account — charges, customers, and billing tools.",
     },
     {
         "id": "vercel",

package/workframe-api/rooms.py

@@ -1304,6 +1304,9 @@ def _workspace_credential_mode(conn: sqlite3.Connection | None, workspace_id: st
         settings = _srv()._parse_workspace_settings(row) if row else {}
         mode = str(settings.get("credential_mode") or "byok").strip().lower()
         return mode if mode in ("byok", "workspace") else "byok"
+    except sqlite3.Error:
+        # Before bootstrap creates the workspace schema, BYOK is the safe default.
+        return "byok"
     finally:
         if own_conn:
             conn.close()

package/workframe-api/route_registry.py

@@ -146,6 +146,7 @@ ROUTES: tuple[Route, ...] = (
     Route("POST", "/api/admin/vault/wipe", AuthLevel.ROLE_OWNER_ADMIN, "_route_post_admin_vault_wipe"),
     Route("POST", "/api/install/stack/branding-asset", AuthLevel.ROLE_OWNER_ADMIN, "_route_post_install_stack_branding_asset"),
     # --- install-window POST ---
+    Route("POST", "/api/install/register-admin", AuthLevel.PUBLIC, "_route_post_install_register_admin", install_window=True),
     Route("POST", "/api/install/email/test", AuthLevel.PUBLIC, "_route_post_install_email_test", install_window=True),
     Route("POST", "/api/install/url/test", AuthLevel.PUBLIC, "_route_post_install_url_test", install_window=True),
     Route("POST", "/api/install/setup-https", AuthLevel.PUBLIC, "_route_post_install_setup_https", install_window=True),

package/workframe-api/run_ledger.py

@@ -11,6 +11,7 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Mapping
 
+import llm_error_glossary
 from domain.entities import (
     ActorType,
     FundingSource,
@@ -423,18 +424,21 @@ def list_run_events_for_room(room_id: str, *, limit: int = 40) -> list[dict[str,
             payload = json.loads(str(row["payload_json"] or "{}"))
         except json.JSONDecodeError:
             payload = {}
+        event_type = str(row["event_type"])
+        if event_type == "run.authorized":
+            continue
         out.append(
             {
                 "id": f"run_event:{row['event_id']}",
                 "kind": "run_event",
-                "event_type": str(row["event_type"]),
+                "event_type": event_type,
                 "run_id": str(row["run_id"]),
                 "run_status": str(row["run_status"]),
                 "profile": str(row["profile_slug"] or ""),
                 "payer_user_id": str(row["payer_user_id"] or ""),
                 "funding_source": str(row["funding_source"] or ""),
-                "task_description": _event_description(str(row["event_type"]), payload),
-                "status": str(row["run_status"]),
+                "task_description": _event_description(event_type, payload),
+                "status": _activity_status_for_event(event_type, str(row["run_status"])),
                 "created_at": str(row["created_at"]),
                 "source": "run_ledger",
                 "payload": payload,
@@ -443,16 +447,56 @@ def list_run_events_for_room(room_id: str, *, limit: int = 40) -> list[dict[str,
     return out
 
 
+def _activity_status_for_event(event_type: str, run_status: str) -> str:
+    et = str(event_type or "").strip().lower()
+    if et == "run.completed":
+        return "completed"
+    if et in ("run.failed", "run.denied"):
+        return "failed"
+    rs = str(run_status or "").strip().lower()
+    if rs == "running":
+        return "active"
+    if rs == "completed":
+        return "completed"
+    if rs in ("failed", "denied", "cancelled"):
+        return "failed"
+    return "idle"
+
+
+def _humanize_run_failure(reason: str) -> str:
+    raw = str(reason or "").strip()
+    if not raw:
+        return "Turn failed"
+    entry = llm_error_glossary.classify_exception_text(raw)
+    msg = str(entry.get("message") or "").strip()
+    if msg:
+        return msg
+    return raw[:160]
+
+
+def _humanize_deny_reason(reason: str) -> str:
+    key = str(reason or "").strip().lower()
+    labels = {
+        "no_credential_byok": "connect an LLM provider in Settings",
+        "no_credential": "connect an LLM provider in Settings",
+        "policy": "policy blocked this turn",
+    }
+    return labels.get(key, key.replace("_", " ") or "policy")
+
+
 def _event_description(event_type: str, payload: Mapping[str, Any]) -> str:
     if event_type == "run.authorized":
-        fs = str(payload.get("funding_source") or "")
-        return f"Run authorized ({fs})" if fs else "Run authorized"
+        return ""
     if event_type == "run.denied":
-        return f"Run denied: {payload.get('deny_reason') or 'policy'}"
+        return f"Turn blocked — {_humanize_deny_reason(str(payload.get('deny_reason') or 'policy'))}"
     if event_type == "run.completed":
-        return "Chat turn completed"
+        model = str(payload.get("model") or "").strip()
+        if model:
+            short = model.rsplit("/", 1)[-1]
+            return f"Reply delivered · {short}"
+        return "Reply delivered"
     if event_type == "run.failed":
-        return f"Run failed: {payload.get('reason') or 'error'}"
+        return _humanize_run_failure(str(payload.get("reason") or payload.get("code") or ""))
     if event_type == "slash.command":
         cmd = str(payload.get("command") or "")
         return f"Slash /{cmd}" if cmd else "Slash command"

package/workframe-api/runtime_cohort.py

@@ -570,10 +570,12 @@ def _purge_runtime_profile(runtime: str) -> None:
 
 
 def _register_runtime_profile(runtime: str, template: str) -> None:
+    _srv()._ensure_profiles_dir_ready()
     cmd = ["profile", "create", "--clone-from", template, runtime]
     code, out = _srv()._gateway_exec(_srv()._primary_profile(), cmd)
     if code == 0:
         _inherit_runtime_profile_config(runtime, template)
+        _srv()._chown_profile_tree(_srv()._profile_dir(runtime))
         return
     out_l = out.lower()
     if "already exists" in out_l:
@@ -583,6 +585,7 @@ def _register_runtime_profile(runtime: str, template: str) -> None:
         code, out = _srv()._gateway_exec(_srv()._primary_profile(), cmd)
         if code == 0:
             _inherit_runtime_profile_config(runtime, template)
+            _srv()._chown_profile_tree(_srv()._profile_dir(runtime))
             return
     if code != 0:
         raise ValueError(f"runtime profile create failed: {out.strip()}")
@@ -709,6 +712,7 @@ def ensure_runtime_profile(
     user_id: str,
     workspace_id: str = "",
 ) -> None:
+    _srv()._ensure_profiles_dir_ready()
     runtime = _srv().safe_profile_slug(runtime_slug)
     template = _srv().resolve_validated_profile(template_slug)
     if _runtime_profile_on_disk(runtime):
@@ -726,10 +730,16 @@ def ensure_runtime_profile(
         if not _profile_toolsets_ready(runtime, _srv()._chat_toolsets_for_profile(runtime)):
             _srv()._ensure_profile_toolsets(runtime)
         _ensure_profile_terminal_cwd(runtime)
-        # ponytail: do not re-sync template model on every bind — destroys per-user reconcile
+        # Existing profiles still need invariant repair.  This deliberately does
+        # not copy template model preferences; reconciliation keeps the agent's
+        # model when the acting user can use it and falls back to that user's
+        # connected providers otherwise.
+        _prepare_runtime_profile_credentials(runtime, user_id, workspace_id)
+        _srv()._ensure_profile_proxy_headers(runtime)
         return
     _purge_runtime_profile(runtime)
     _register_runtime_profile(runtime, template)
+    _srv()._chown_profile_tree(_srv()._profile_dir(runtime))
     if _srv()._profile_config_path(runtime) is None:
         raise ValueError(f"runtime profile bootstrap failed: {runtime}")
     # SOUL: clone inherits template at profile create; do not auto-overwrite on disk later.

package/workframe-api/server.py

@@ -190,6 +190,7 @@ _register_runtime_profile = runtime_cohort._register_runtime_profile
 _inherit_runtime_profile_config = runtime_cohort._inherit_runtime_profile_config
 ensure_runtime_profile = runtime_cohort.ensure_runtime_profile
 _ensure_profile_terminal_cwd = runtime_cohort._ensure_profile_terminal_cwd
+_profile_toolsets_ready = runtime_cohort._profile_toolsets_ready
 
 health_data = health_monitor.health_data
 build_snapshot = snapshot_feed.build_snapshot
@@ -256,6 +257,7 @@ _user_has_llm_provider = provider_bootstrap._user_has_llm_provider
 _user_llm_has_provider = provider_bootstrap._user_llm_has_provider
 _workspace_has_llm_provider = provider_bootstrap._workspace_has_llm_provider
 _user_can_use_llm = provider_bootstrap._user_can_use_llm
+_invalidate_user_llm_picker_cache = provider_bootstrap.invalidate_user_llm_picker_cache
 _overlay_chat_llm_env = provider_bootstrap._overlay_chat_llm_env
 _reconcile_profile_llm_for_user = provider_bootstrap._reconcile_profile_llm_for_user
 _ensure_profile_auth_pool = provider_bootstrap._ensure_profile_auth_pool
@@ -332,6 +334,7 @@ _native_profile_slug = hermes_profiles._native_profile_slug
 _native_profile_present = hermes_profiles._native_profile_present
 _hermes_data_uid_gid = hermes_profiles._hermes_data_uid_gid
 _chown_profile_tree = hermes_profiles._chown_profile_tree
+_ensure_profiles_dir_ready = hermes_profiles._ensure_profiles_dir_ready
 _seed_native_profile_on_disk = hermes_profiles._seed_native_profile_on_disk
 _ensure_native_hermes_profile = hermes_profiles._ensure_native_hermes_profile
 _primary_profile = hermes_profiles._primary_profile
@@ -613,9 +616,14 @@ import zk_auth as _zk
 _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 = 60.0
 _SESSION_INFO_TTL_SEC = 5.0
 
 
+def _invalidate_profile_health_cache(profile: str) -> None:
+    _profile_health_cache.pop(str(profile or "").strip(), None)
+
+
 def _install_window_open() -> bool:
     try:
         return install_api.install_window_open(str(DATA_DIR / "workframe.db"))
@@ -1366,6 +1374,7 @@ _read_profile_lease_token = turn_overlay._read_profile_lease_token
 _lease_reusable_for_turn = turn_overlay._lease_reusable_for_turn
 _read_config_model_api_key = turn_overlay._read_config_model_api_key
 _sync_profile_model_api_key = turn_overlay._sync_profile_model_api_key
+_schedule_profile_lease_yaml_reconcile = turn_overlay._schedule_profile_lease_yaml_reconcile
 _apply_turn_credential_lease = turn_overlay._apply_turn_credential_lease
 _action_proxy_base_url = turn_overlay._action_proxy_base_url
 _action_proxy_env_var = turn_overlay._action_proxy_env_var
@@ -1388,6 +1397,7 @@ _parse_user_content_segments = chat_sessions._parse_user_content_segments
 _parse_tool_content = chat_sessions._parse_tool_content
 _message_row_segments = chat_sessions._message_row_segments
 _llm_attribution_for_profile = chat_sessions._llm_attribution_for_profile
+_profile_model = chat_sessions._profile_model
 _latest_session_id = chat_sessions._latest_session_id
 _session_info = chat_sessions._session_info
 _is_blank_session_title = chat_sessions._is_blank_session_title
@@ -1460,12 +1470,26 @@ def _enrich_room_messages(conn: sqlite3.Connection, messages: list[Any]) -> list
         agent_id = str(item.get("sender_agent_id") or "").strip()
         if agent_id:
             agent = conn.execute(
-                "SELECT slug, display_name FROM agent_profiles WHERE id = ? AND deleted_at IS NULL",
+                """
+                SELECT slug, display_name, model_name, model_provider
+                FROM agent_profiles WHERE id = ? AND deleted_at IS NULL
+                """,
                 (agent_id,),
             ).fetchone()
             if agent:
                 item["sender_agent_slug"] = str(agent["slug"])
                 item["sender_agent_name"] = str(agent["display_name"] or agent["slug"])
+                model_name = str(agent["model_name"] or "").strip()
+                model_provider = str(agent["model_provider"] or "").strip()
+                slug = str(agent["slug"] or "").strip()
+                if not model_name and slug:
+                    model_name = str(_read_model_block(slug).get("default") or "").strip()
+                if not model_provider and slug:
+                    model_provider = _llm_billing_provider(slug)
+                if model_name:
+                    item["model"] = model_name
+                if model_provider:
+                    item["llm_provider"] = model_provider
         enriched.append(item)
     return enriched
 

package/workframe-api/stack_config.py

@@ -375,7 +375,10 @@ def mark_install_admin_verified(email: str) -> None:
     smtp["admin_email"] = normalized
     smtp["admin_verified_at"] = int(time.time())
     raw["smtp"] = smtp
-    raw["wizard_step"] = "workframe"
+    if not str(raw.get("deployment_mode") or "").strip():
+        raw["wizard_step"] = "welcome"
+    else:
+        raw["wizard_step"] = "workframe"
     _write_raw(raw)